home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / arch / s390 / include / asm / cputime.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  3.7 KB  |  178 lines

  1. /*
  2.  *  include/asm-s390/cputime.h
  3.  *
  4.  *  (C) Copyright IBM Corp. 2004
  5.  *
  6.  *  Author: Martin Schwidefsky <schwidefsky@de.ibm.com>
  7.  */
  8.  
  9. #ifndef _S390_CPUTIME_H
  10. #define _S390_CPUTIME_H
  11.  
  12. #include <asm/div64.h>
  13.  
  14. /* We want to use micro-second resolution. */
  15.  
  16. typedef unsigned long long cputime_t;
  17. typedef unsigned long long cputime64_t;
  18.  
  19. #ifndef __s390x__
  20.  
  21. static inline unsigned int
  22. __div(unsigned long long n, unsigned int base)
  23. {
  24.     register_pair rp;
  25.  
  26.     rp.pair = n >> 1;
  27.     asm ("dr %0,%1" : "+d" (rp) : "d" (base >> 1));
  28.     return rp.subreg.odd;
  29. }
  30.  
  31. #else /* __s390x__ */
  32.  
  33. static inline unsigned int
  34. __div(unsigned long long n, unsigned int base)
  35. {
  36.     return n / base;
  37. }
  38.  
  39. #endif /* __s390x__ */
  40.  
  41. #define cputime_zero            (0ULL)
  42. #define cputime_max            ((~0UL >> 1) - 1)
  43. #define cputime_add(__a, __b)        ((__a) +  (__b))
  44. #define cputime_sub(__a, __b)        ((__a) -  (__b))
  45. #define cputime_div(__a, __n) ({        \
  46.     unsigned long long __div = (__a);    \
  47.     do_div(__div,__n);            \
  48.     __div;                    \
  49. })
  50. #define cputime_halve(__a)        ((__a) >> 1)
  51. #define cputime_eq(__a, __b)        ((__a) == (__b))
  52. #define cputime_gt(__a, __b)        ((__a) >  (__b))
  53. #define cputime_ge(__a, __b)        ((__a) >= (__b))
  54. #define cputime_lt(__a, __b)        ((__a) <  (__b))
  55. #define cputime_le(__a, __b)        ((__a) <= (__b))
  56. #define cputime_to_jiffies(__ct)    (__div((__ct), 1000000 / HZ))
  57. #define cputime_to_scaled(__ct)        (__ct)
  58. #define jiffies_to_cputime(__hz)    ((cputime_t)(__hz) * (1000000 / HZ))
  59.  
  60. #define cputime64_zero            (0ULL)
  61. #define cputime64_add(__a, __b)        ((__a) + (__b))
  62. #define cputime_to_cputime64(__ct)    (__ct)
  63.  
  64. static inline u64
  65. cputime64_to_jiffies64(cputime64_t cputime)
  66. {
  67.     do_div(cputime, 1000000 / HZ);
  68.     return cputime;
  69. }
  70.  
  71. /*
  72.  * Convert cputime to milliseconds and back.
  73.  */
  74. static inline unsigned int
  75. cputime_to_msecs(const cputime_t cputime)
  76. {
  77.     return __div(cputime, 1000);
  78. }
  79.  
  80. static inline cputime_t
  81. msecs_to_cputime(const unsigned int m)
  82. {
  83.     return (cputime_t) m * 1000;
  84. }
  85.  
  86. /*
  87.  * Convert cputime to milliseconds and back.
  88.  */
  89. static inline unsigned int
  90. cputime_to_secs(const cputime_t cputime)
  91. {
  92.     return __div(cputime, 1000000);
  93. }
  94.  
  95. static inline cputime_t
  96. secs_to_cputime(const unsigned int s)
  97. {
  98.     return (cputime_t) s * 1000000;
  99. }
  100.  
  101. /*
  102.  * Convert cputime to timespec and back.
  103.  */
  104. static inline cputime_t
  105. timespec_to_cputime(const struct timespec *value)
  106. {
  107.         return value->tv_nsec / 1000 + (u64) value->tv_sec * 1000000;
  108. }
  109.  
  110. static inline void
  111. cputime_to_timespec(const cputime_t cputime, struct timespec *value)
  112. {
  113. #ifndef __s390x__
  114.     register_pair rp;
  115.  
  116.     rp.pair = cputime >> 1;
  117.     asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));
  118.     value->tv_nsec = rp.subreg.even * 1000;
  119.     value->tv_sec = rp.subreg.odd;
  120. #else
  121.     value->tv_nsec = (cputime % 1000000) * 1000;
  122.     value->tv_sec = cputime / 1000000;
  123. #endif
  124. }
  125.  
  126. /*
  127.  * Convert cputime to timeval and back.
  128.  * Since cputime and timeval have the same resolution (microseconds)
  129.  * this is easy.
  130.  */
  131. static inline cputime_t
  132. timeval_to_cputime(const struct timeval *value)
  133. {
  134.         return value->tv_usec + (u64) value->tv_sec * 1000000;
  135. }
  136.  
  137. static inline void
  138. cputime_to_timeval(const cputime_t cputime, struct timeval *value)
  139. {
  140. #ifndef __s390x__
  141.     register_pair rp;
  142.  
  143.     rp.pair = cputime >> 1;
  144.     asm ("dr %0,%1" : "+d" (rp) : "d" (1000000 >> 1));
  145.     value->tv_usec = rp.subreg.even;
  146.     value->tv_sec = rp.subreg.odd;
  147. #else
  148.     value->tv_usec = cputime % 1000000;
  149.     value->tv_sec = cputime / 1000000;
  150. #endif
  151. }
  152.  
  153. /*
  154.  * Convert cputime to clock and back.
  155.  */
  156. static inline clock_t
  157. cputime_to_clock_t(cputime_t cputime)
  158. {
  159.     return __div(cputime, 1000000 / USER_HZ);
  160. }
  161.  
  162. static inline cputime_t
  163. clock_t_to_cputime(unsigned long x)
  164. {
  165.     return (cputime_t) x * (1000000 / USER_HZ);
  166. }
  167.  
  168. /*
  169.  * Convert cputime64 to clock.
  170.  */
  171. static inline clock_t
  172. cputime64_to_clock_t(cputime64_t cputime)
  173. {
  174.        return __div(cputime, 1000000 / USER_HZ);
  175. }
  176.  
  177. #endif /* _S390_CPUTIME_H */
  178.