1 /* 2 * Definitions for measuring cputime on powerpc machines. 3 * 4 * Copyright (C) 2006 Paul Mackerras, IBM Corp. 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * as published by the Free Software Foundation; either version 9 * 2 of the License, or (at your option) any later version. 10 * 11 * If we have CONFIG_VIRT_CPU_ACCOUNTING_NATIVE, we measure cpu time in 12 * the same units as the timebase. Otherwise we measure cpu time 13 * in jiffies using the generic definitions. 14 */ 15 16 #ifndef __POWERPC_CPUTIME_H 17 #define __POWERPC_CPUTIME_H 18 19 #ifndef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE 20 #include <asm-generic/cputime.h> 21 #ifdef __KERNEL__ 22 static inline void setup_cputime_one_jiffy(void) { } 23 #endif 24 #else 25 26 #include <linux/types.h> 27 #include <linux/time.h> 28 #include <asm/div64.h> 29 #include <asm/time.h> 30 #include <asm/param.h> 31 32 typedef u64 __nocast cputime_t; 33 typedef u64 __nocast cputime64_t; 34 35 #ifdef __KERNEL__ 36 37 /* 38 * One jiffy in timebase units computed during initialization 39 */ 40 extern cputime_t cputime_one_jiffy; 41 42 /* 43 * Convert cputime <-> jiffies 44 */ 45 extern u64 __cputime_jiffies_factor; 46 DECLARE_PER_CPU(unsigned long, cputime_last_delta); 47 DECLARE_PER_CPU(unsigned long, cputime_scaled_last_delta); 48 49 static inline unsigned long cputime_to_jiffies(const cputime_t ct) 50 { 51 return mulhdu((__force u64) ct, __cputime_jiffies_factor); 52 } 53 54 /* Estimate the scaled cputime by scaling the real cputime based on 55 * the last scaled to real ratio */ 56 static inline cputime_t cputime_to_scaled(const cputime_t ct) 57 { 58 if (cpu_has_feature(CPU_FTR_SPURR) && 59 __get_cpu_var(cputime_last_delta)) 60 return (__force u64) ct * 61 __get_cpu_var(cputime_scaled_last_delta) / 62 __get_cpu_var(cputime_last_delta); 63 return ct; 64 } 65 66 static inline cputime_t jiffies_to_cputime(const unsigned long jif) 67 { 68 u64 ct; 69 unsigned long sec; 70 71 /* have to be a little careful about overflow */ 72 ct = jif % HZ; 73 sec = jif / HZ; 74 if (ct) { 75 ct *= tb_ticks_per_sec; 76 do_div(ct, HZ); 77 } 78 if (sec) 79 ct += (cputime_t) sec * tb_ticks_per_sec; 80 return (__force cputime_t) ct; 81 } 82 83 static inline void setup_cputime_one_jiffy(void) 84 { 85 cputime_one_jiffy = jiffies_to_cputime(1); 86 } 87 88 static inline cputime64_t jiffies64_to_cputime64(const u64 jif) 89 { 90 u64 ct; 91 u64 sec; 92 93 /* have to be a little careful about overflow */ 94 ct = jif % HZ; 95 sec = jif / HZ; 96 if (ct) { 97 ct *= tb_ticks_per_sec; 98 do_div(ct, HZ); 99 } 100 if (sec) 101 ct += (u64) sec * tb_ticks_per_sec; 102 return (__force cputime64_t) ct; 103 } 104 105 static inline u64 cputime64_to_jiffies64(const cputime_t ct) 106 { 107 return mulhdu((__force u64) ct, __cputime_jiffies_factor); 108 } 109 110 /* 111 * Convert cputime <-> microseconds 112 */ 113 extern u64 __cputime_usec_factor; 114 115 static inline unsigned long cputime_to_usecs(const cputime_t ct) 116 { 117 return mulhdu((__force u64) ct, __cputime_usec_factor); 118 } 119 120 static inline cputime_t usecs_to_cputime(const unsigned long us) 121 { 122 u64 ct; 123 unsigned long sec; 124 125 /* have to be a little careful about overflow */ 126 ct = us % 1000000; 127 sec = us / 1000000; 128 if (ct) { 129 ct *= tb_ticks_per_sec; 130 do_div(ct, 1000000); 131 } 132 if (sec) 133 ct += (cputime_t) sec * tb_ticks_per_sec; 134 return (__force cputime_t) ct; 135 } 136 137 #define usecs_to_cputime64(us) usecs_to_cputime(us) 138 139 /* 140 * Convert cputime <-> seconds 141 */ 142 extern u64 __cputime_sec_factor; 143 144 static inline unsigned long cputime_to_secs(const cputime_t ct) 145 { 146 return mulhdu((__force u64) ct, __cputime_sec_factor); 147 } 148 149 static inline cputime_t secs_to_cputime(const unsigned long sec) 150 { 151 return (__force cputime_t)((u64) sec * tb_ticks_per_sec); 152 } 153 154 /* 155 * Convert cputime <-> timespec 156 */ 157 static inline void cputime_to_timespec(const cputime_t ct, struct timespec *p) 158 { 159 u64 x = (__force u64) ct; 160 unsigned int frac; 161 162 frac = do_div(x, tb_ticks_per_sec); 163 p->tv_sec = x; 164 x = (u64) frac * 1000000000; 165 do_div(x, tb_ticks_per_sec); 166 p->tv_nsec = x; 167 } 168 169 static inline cputime_t timespec_to_cputime(const struct timespec *p) 170 { 171 u64 ct; 172 173 ct = (u64) p->tv_nsec * tb_ticks_per_sec; 174 do_div(ct, 1000000000); 175 return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec); 176 } 177 178 /* 179 * Convert cputime <-> timeval 180 */ 181 static inline void cputime_to_timeval(const cputime_t ct, struct timeval *p) 182 { 183 u64 x = (__force u64) ct; 184 unsigned int frac; 185 186 frac = do_div(x, tb_ticks_per_sec); 187 p->tv_sec = x; 188 x = (u64) frac * 1000000; 189 do_div(x, tb_ticks_per_sec); 190 p->tv_usec = x; 191 } 192 193 static inline cputime_t timeval_to_cputime(const struct timeval *p) 194 { 195 u64 ct; 196 197 ct = (u64) p->tv_usec * tb_ticks_per_sec; 198 do_div(ct, 1000000); 199 return (__force cputime_t)(ct + (u64) p->tv_sec * tb_ticks_per_sec); 200 } 201 202 /* 203 * Convert cputime <-> clock_t (units of 1/USER_HZ seconds) 204 */ 205 extern u64 __cputime_clockt_factor; 206 207 static inline unsigned long cputime_to_clock_t(const cputime_t ct) 208 { 209 return mulhdu((__force u64) ct, __cputime_clockt_factor); 210 } 211 212 static inline cputime_t clock_t_to_cputime(const unsigned long clk) 213 { 214 u64 ct; 215 unsigned long sec; 216 217 /* have to be a little careful about overflow */ 218 ct = clk % USER_HZ; 219 sec = clk / USER_HZ; 220 if (ct) { 221 ct *= tb_ticks_per_sec; 222 do_div(ct, USER_HZ); 223 } 224 if (sec) 225 ct += (u64) sec * tb_ticks_per_sec; 226 return (__force cputime_t) ct; 227 } 228 229 #define cputime64_to_clock_t(ct) cputime_to_clock_t((cputime_t)(ct)) 230 231 static inline void arch_vtime_task_switch(struct task_struct *tsk) { } 232 233 #endif /* __KERNEL__ */ 234 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */ 235 #endif /* __POWERPC_CPUTIME_H */ 236