adulau/aha
1
0
Fork 0
mirror of https://github.com/adulau/aha.git synced 2024-12-28 03:36:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

convert a few do_div users

Browse source 
This converts a few users of do_div to div_[su]64 and this demonstrates nicely
how it can reduce some expressions to one-liners.

Signed-off-by: Roman Zippel <zippel@linux-m68k.org>
Cc: john stultz <johnstul@us.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Roman Zippel 2008-05-01 04:34:26 -07:00 committed by Linus Torvalds
parent 2418f4f28f
commit 71abb3af62
2 changed files with 15 additions and 39 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
kernel/time.c
View file

@ -36,6 +36,7 @@
#include <linux/security.h> #include <linux/security.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/math64.h>
#include <asm/uaccess.h> #include <asm/uaccess.h>
#include <asm/unistd.h> #include <asm/unistd.h>
@ -587,9 +588,7 @@ clock_t jiffies_to_clock_t(long x)
return x / (HZ / USER_HZ); return x / (HZ / USER_HZ);
# endif # endif
#else #else
u64 tmp = (u64)x * TICK_NSEC; return div_u64((u64)x * TICK_NSEC, NSEC_PER_SEC / USER_HZ);
do_div(tmp, (NSEC_PER_SEC / USER_HZ));
return (long)tmp;
#endif #endif
} }
EXPORT_SYMBOL(jiffies_to_clock_t); EXPORT_SYMBOL(jiffies_to_clock_t);
@ -601,16 +600,12 @@ unsigned long clock_t_to_jiffies(unsigned long x)
return ~0UL; return ~0UL;
return x * (HZ / USER_HZ); return x * (HZ / USER_HZ);
#else #else
u64 jif;
/* Don't worry about loss of precision here .. */ /* Don't worry about loss of precision here .. */
if (x >= ~0UL / HZ * USER_HZ) if (x >= ~0UL / HZ * USER_HZ)
return ~0UL; return ~0UL;
/* .. but do try to contain it here */ /* .. but do try to contain it here */
jif = x * (u64) HZ; return div_u64((u64)x * HZ, USER_HZ);
do_div(jif, USER_HZ);
return jif;
#endif #endif
} }
EXPORT_SYMBOL(clock_t_to_jiffies); EXPORT_SYMBOL(clock_t_to_jiffies);
@ -619,10 +614,9 @@ u64 jiffies_64_to_clock_t(u64 x)
{ {
#if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0 #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
# if HZ < USER_HZ # if HZ < USER_HZ
x *= USER_HZ; x = div_u64(x * USER_HZ, HZ);
do_div(x, HZ);
# elif HZ > USER_HZ # elif HZ > USER_HZ
do_div(x, HZ / USER_HZ); x = div_u64(x, HZ / USER_HZ);
# else # else
/* Nothing to do */ /* Nothing to do */
# endif # endif
@ -632,8 +626,7 @@ u64 jiffies_64_to_clock_t(u64 x)
* but even this doesn't overflow in hundreds of years * but even this doesn't overflow in hundreds of years
* in 64 bits, so.. * in 64 bits, so..
*/ */
x *= TICK_NSEC; x = div_u64(x * TICK_NSEC, (NSEC_PER_SEC / USER_HZ));
do_div(x, (NSEC_PER_SEC / USER_HZ));
#endif #endif
return x; return x;
} }
@ -642,21 +635,17 @@ EXPORT_SYMBOL(jiffies_64_to_clock_t);
u64 nsec_to_clock_t(u64 x) u64 nsec_to_clock_t(u64 x)
{ {
#if (NSEC_PER_SEC % USER_HZ) == 0 #if (NSEC_PER_SEC % USER_HZ) == 0
do_div(x, (NSEC_PER_SEC / USER_HZ)); return div_u64(x, NSEC_PER_SEC / USER_HZ);
#elif (USER_HZ % 512) == 0 #elif (USER_HZ % 512) == 0
x *= USER_HZ/512; return div_u64(x * USER_HZ / 512, NSEC_PER_SEC / 512);
do_div(x, (NSEC_PER_SEC / 512));
#else #else
/* /*
* max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024, * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
* overflow after 64.99 years. * overflow after 64.99 years.
* exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ... * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
*/ */
x *= 9; return div_u64(x * 9, (9ull * NSEC_PER_SEC + (USER_HZ / 2)) / USER_HZ);
do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2)) /
USER_HZ));
#endif #endif
return x;
} }
#if (BITS_PER_LONG < 64) #if (BITS_PER_LONG < 64)

25
kernel/time/ntp.c
View file

@ -15,7 +15,7 @@
#include <linux/jiffies.h> #include <linux/jiffies.h>
#include <linux/hrtimer.h> #include <linux/hrtimer.h>
#include <linux/capability.h> #include <linux/capability.h>
#include <asm/div64.h> #include <linux/math64.h>
#include <asm/timex.h> #include <asm/timex.h>
/* /*
@ -53,10 +53,8 @@ static void ntp_update_frequency(void)
tick_length_base = second_length; tick_length_base = second_length;
do_div(second_length, HZ); tick_nsec = div_u64(second_length, HZ) >> TICK_LENGTH_SHIFT;
tick_nsec = second_length >> TICK_LENGTH_SHIFT; tick_length_base = div_u64(tick_length_base, NTP_INTERVAL_FREQ);
do_div(tick_length_base, NTP_INTERVAL_FREQ);
} }
/** /**
@ -237,7 +235,7 @@ static inline void notify_cmos_timer(void) { }
int do_adjtimex(struct timex *txc) int do_adjtimex(struct timex *txc)
{ {
long mtemp, save_adjust, rem; long mtemp, save_adjust, rem;
s64 freq_adj, temp64; s64 freq_adj;
int result; int result;
/* In order to modify anything, you gotta be super-user! */ /* In order to modify anything, you gotta be super-user! */
@ -342,19 +340,8 @@ int do_adjtimex(struct timex *txc)
freq_adj = time_offset * mtemp; freq_adj = time_offset * mtemp;
freq_adj = shift_right(freq_adj, time_constant * 2 + freq_adj = shift_right(freq_adj, time_constant * 2 +
(SHIFT_PLL + 2) * 2 - SHIFT_NSEC); (SHIFT_PLL + 2) * 2 - SHIFT_NSEC);
if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC)) { if (mtemp >= MINSEC && (time_status & STA_FLL || mtemp > MAXSEC))
u64 utemp64; freq_adj += div_s64(time_offset << (SHIFT_NSEC - SHIFT_FLL), mtemp);
temp64 = time_offset << (SHIFT_NSEC - SHIFT_FLL);
if (time_offset < 0) {
utemp64 = -temp64;
do_div(utemp64, mtemp);
freq_adj -= utemp64;
} else {
utemp64 = temp64;
do_div(utemp64, mtemp);
freq_adj += utemp64;
}
}
freq_adj += time_freq; freq_adj += time_freq;
freq_adj = min(freq_adj, (s64)MAXFREQ_NSEC); freq_adj = min(freq_adj, (s64)MAXFREQ_NSEC);
time_freq = max(freq_adj, (s64)-MAXFREQ_NSEC); time_freq = max(freq_adj, (s64)-MAXFREQ_NSEC);