On 06/27/2016 02:29 PM, David Laight wrote:
From: Arnd Bergmann
quoted
Sent: 24 June 2016 20:43
On Friday, June 24, 2016 9:31:35 PM CEST Shreyas B Prabhu wrote:
quoted
quoted
If those functions are called less often than cpuidle_enter_state(),
we could just move the division there. Since the divisor is constant,
do_div() can convert it into a multiply and shift, or we could use
your the code you suggest above, or use a 32-bit division most of
the time:
if (diff <= UINT_MAX)
diff_32 = (u32)diff / NSECS_PER_USEC;
else
diff_32 = div_u64(diff, NSECS_PER_USEC;
which gcc itself will turn into a multiplication or series of
shifts on CPUs on which that is faster.
I'm not sure which division method of the three suggested here to use.
Does anyone have a strong preference?
It depends on how accurate we want it and how long we expect
the times to be. The optimization for the 4.2 second cutoff
for doing a 32-bit division only makes sense if the majority
of the sleep times are below that.
It also depends if the code actually cares about the length of 'long' sleeps.
I'd guess that for cpu idle 4.2 seconds is 'a long time', so the div_u64()
result could be treated as 4.2 seconds without causing grief.
Actually the cost of a 64bit divide after a 4 second sleep will be noise.
OTOH a 64bit divide after a sleep that lasted a few ns will be significant.
Agreed. I'll use the code you suggested, with a small change-
Using diff_32 += diff_32 >> 5 instead of diff_32 += diff_32 >> 6
since I want to err on the side of last_residency being more than actual.
And for long sleep cases, I'll use div_u64().
Thanks,
Shreyas