lkml.org 
[lkml]   [2019]   [Aug]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
Date
From
Subject[tip: timers/core] posix-cpu-timers: Get rid of 64bit divisions
The following commit has been merged into the timers/core branch of tip:

Commit-ID: 8ea1de90a5eccdc18c8f05f8596bae8660a3ff9a
Gitweb: https://git.kernel.org/tip/8ea1de90a5eccdc18c8f05f8596bae8660a3ff9a
Author: Thomas Gleixner <tglx@linutronix.de>
AuthorDate: Wed, 21 Aug 2019 21:09:21 +02:00
Committer: Thomas Gleixner <tglx@linutronix.de>
CommitterDate: Wed, 28 Aug 2019 11:50:41 +02:00

posix-cpu-timers: Get rid of 64bit divisions

Instead of dividing A to match the units of B it's more efficient to
multiply B to match the units of A.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Frederic Weisbecker <frederic@kernel.org>
Link: https://lkml.kernel.org/r/20190821192922.458286860@linutronix.de

---
kernel/time/posix-cpu-timers.c | 24 ++++++++++++++----------
1 file changed, 14 insertions(+), 10 deletions(-)

diff --git a/kernel/time/posix-cpu-timers.c b/kernel/time/posix-cpu-timers.c
index caafdfd..dcdf9c8 100644
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -798,10 +798,11 @@ static void check_thread_timers(struct task_struct *tsk,
*/
soft = task_rlimit(tsk, RLIMIT_RTTIME);
if (soft != RLIM_INFINITY) {
+ /* Task RT timeout is accounted in jiffies. RTTIME is usec */
+ unsigned long rtim = tsk->rt.timeout * (USEC_PER_SEC / HZ);
unsigned long hard = task_rlimit_max(tsk, RLIMIT_RTTIME);

- if (hard != RLIM_INFINITY &&
- tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) {
+ if (hard != RLIM_INFINITY && rtim >= hard) {
/*
* At the hard limit, we just die.
* No need to calculate anything else now.
@@ -813,7 +814,7 @@ static void check_thread_timers(struct task_struct *tsk,
__group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
return;
}
- if (tsk->rt.timeout > DIV_ROUND_UP(soft, USEC_PER_SEC/HZ)) {
+ if (rtim >= soft) {
/*
* At the soft limit, send a SIGXCPU every second.
*/
@@ -910,11 +911,13 @@ static void check_process_timers(struct task_struct *tsk,

soft = task_rlimit(tsk, RLIMIT_CPU);
if (soft != RLIM_INFINITY) {
- u64 softns, ptime = samples[CPUCLOCK_PROF];
+ /* RLIMIT_CPU is in seconds. Samples are nanoseconds */
unsigned long hard = task_rlimit_max(tsk, RLIMIT_CPU);
- unsigned long psecs = div_u64(ptime, NSEC_PER_SEC);
+ u64 ptime = samples[CPUCLOCK_PROF];
+ u64 softns = (u64)soft * NSEC_PER_SEC;
+ u64 hardns = (u64)hard * NSEC_PER_SEC;

- if (hard != RLIM_INFINITY && psecs >= hard) {
+ if (hard != RLIM_INFINITY && ptime >= hardns) {
/*
* At the hard limit, we just die.
* No need to calculate anything else now.
@@ -926,7 +929,7 @@ static void check_process_timers(struct task_struct *tsk,
__group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
return;
}
- if (psecs >= soft) {
+ if (ptime >= softns) {
/*
* At the soft limit, send a SIGXCPU every second.
*/
@@ -936,11 +939,12 @@ static void check_process_timers(struct task_struct *tsk,
}
__group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
if (soft < hard) {
- soft++;
- sig->rlim[RLIMIT_CPU].rlim_cur = soft;
+ sig->rlim[RLIMIT_CPU].rlim_cur = soft + 1;
+ softns += NSEC_PER_SEC;
}
}
- softns = soft * NSEC_PER_SEC;
+
+ /* Update the expiry cache */
if (softns < pct->bases[CPUCLOCK_PROF].nextevt)
pct->bases[CPUCLOCK_PROF].nextevt = softns;
}
\
 
 \ /
  Last update: 2019-08-28 12:17    [W:0.316 / U:6.556 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site