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:5.935 / U:0.068 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site