Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cputime.h
Go to the documentation of this file.
1 /*
2  * Copyright IBM Corp. 2004
3  *
4  * Author: Martin Schwidefsky <[email protected]>
5  */
6 
7 #ifndef _S390_CPUTIME_H
8 #define _S390_CPUTIME_H
9 
10 #include <linux/types.h>
11 #include <linux/percpu.h>
12 #include <linux/spinlock.h>
13 #include <asm/div64.h>
14 
15 
16 #define __ARCH_HAS_VTIME_ACCOUNT
17 
18 /* We want to use full resolution of the CPU timer: 2**-12 micro-seconds. */
19 
20 typedef unsigned long long __nocast cputime_t;
21 typedef unsigned long long __nocast cputime64_t;
22 
23 static inline unsigned long __div(unsigned long long n, unsigned long base)
24 {
25 #ifndef CONFIG_64BIT
27 
28  rp.pair = n >> 1;
29  asm ("dr %0,%1" : "+d" (rp) : "d" (base >> 1));
30  return rp.subreg.odd;
31 #else /* CONFIG_64BIT */
32  return n / base;
33 #endif /* CONFIG_64BIT */
34 }
35 
36 #define cputime_one_jiffy jiffies_to_cputime(1)
37 
38 /*
39  * Convert cputime to jiffies and back.
40  */
41 static inline unsigned long cputime_to_jiffies(const cputime_t cputime)
42 {
43  return __div((__force unsigned long long) cputime, 4096000000ULL / HZ);
44 }
45 
46 static inline cputime_t jiffies_to_cputime(const unsigned int jif)
47 {
48  return (__force cputime_t)(jif * (4096000000ULL / HZ));
49 }
50 
51 static inline u64 cputime64_to_jiffies64(cputime64_t cputime)
52 {
53  unsigned long long jif = (__force unsigned long long) cputime;
54  do_div(jif, 4096000000ULL / HZ);
55  return jif;
56 }
57 
58 static inline cputime64_t jiffies64_to_cputime64(const u64 jif)
59 {
60  return (__force cputime64_t)(jif * (4096000000ULL / HZ));
61 }
62 
63 /*
64  * Convert cputime to microseconds and back.
65  */
66 static inline unsigned int cputime_to_usecs(const cputime_t cputime)
67 {
68  return (__force unsigned long long) cputime >> 12;
69 }
70 
71 static inline cputime_t usecs_to_cputime(const unsigned int m)
72 {
73  return (__force cputime_t)(m * 4096ULL);
74 }
75 
76 #define usecs_to_cputime64(m) usecs_to_cputime(m)
77 
78 /*
79  * Convert cputime to milliseconds and back.
80  */
81 static inline unsigned int cputime_to_secs(const cputime_t cputime)
82 {
83  return __div((__force unsigned long long) cputime, 2048000000) >> 1;
84 }
85 
86 static inline cputime_t secs_to_cputime(const unsigned int s)
87 {
88  return (__force cputime_t)(s * 4096000000ULL);
89 }
90 
91 /*
92  * Convert cputime to timespec and back.
93  */
94 static inline cputime_t timespec_to_cputime(const struct timespec *value)
95 {
96  unsigned long long ret = value->tv_sec * 4096000000ULL;
97  return (__force cputime_t)(ret + value->tv_nsec * 4096 / 1000);
98 }
99 
100 static inline void cputime_to_timespec(const cputime_t cputime,
101  struct timespec *value)
102 {
103  unsigned long long __cputime = (__force unsigned long long) cputime;
104 #ifndef CONFIG_64BIT
106 
107  rp.pair = __cputime >> 1;
108  asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));
109  value->tv_nsec = rp.subreg.even * 1000 / 4096;
110  value->tv_sec = rp.subreg.odd;
111 #else
112  value->tv_nsec = (__cputime % 4096000000ULL) * 1000 / 4096;
113  value->tv_sec = __cputime / 4096000000ULL;
114 #endif
115 }
116 
117 /*
118  * Convert cputime to timeval and back.
119  * Since cputime and timeval have the same resolution (microseconds)
120  * this is easy.
121  */
122 static inline cputime_t timeval_to_cputime(const struct timeval *value)
123 {
124  unsigned long long ret = value->tv_sec * 4096000000ULL;
125  return (__force cputime_t)(ret + value->tv_usec * 4096ULL);
126 }
127 
128 static inline void cputime_to_timeval(const cputime_t cputime,
129  struct timeval *value)
130 {
131  unsigned long long __cputime = (__force unsigned long long) cputime;
132 #ifndef CONFIG_64BIT
134 
135  rp.pair = __cputime >> 1;
136  asm ("dr %0,%1" : "+d" (rp) : "d" (2048000000UL));
137  value->tv_usec = rp.subreg.even / 4096;
138  value->tv_sec = rp.subreg.odd;
139 #else
140  value->tv_usec = (__cputime % 4096000000ULL) / 4096;
141  value->tv_sec = __cputime / 4096000000ULL;
142 #endif
143 }
144 
145 /*
146  * Convert cputime to clock and back.
147  */
148 static inline clock_t cputime_to_clock_t(cputime_t cputime)
149 {
150  unsigned long long clock = (__force unsigned long long) cputime;
151  do_div(clock, 4096000000ULL / USER_HZ);
152  return clock;
153 }
154 
155 static inline cputime_t clock_t_to_cputime(unsigned long x)
156 {
157  return (__force cputime_t)(x * (4096000000ULL / USER_HZ));
158 }
159 
160 /*
161  * Convert cputime64 to clock.
162  */
163 static inline clock_t cputime64_to_clock_t(cputime64_t cputime)
164 {
165  unsigned long long clock = (__force unsigned long long) cputime;
166  do_div(clock, 4096000000ULL / USER_HZ);
167  return clock;
168 }
169 
172  unsigned int sequence;
173  unsigned long long idle_count;
174  unsigned long long idle_time;
175  unsigned long long clock_idle_enter;
176  unsigned long long clock_idle_exit;
177  unsigned long long timer_idle_enter;
178  unsigned long long timer_idle_exit;
179 };
180 
181 DECLARE_PER_CPU(struct s390_idle_data, s390_idle);
182 
184 
185 #define arch_idle_time(cpu) s390_get_idle_time(cpu)
186 
187 static inline int s390_nohz_delay(int cpu)
188 {
189  return __get_cpu_var(s390_idle).nohz_delay != 0;
190 }
191 
192 #define arch_needs_cpu(cpu) s390_nohz_delay(cpu)
193 
194 #endif /* _S390_CPUTIME_H */