diff mbox series

[v4,09/16] timer: Split out "get next timer interrupt" functionality

Message ID 20221104145737.71236-10-anna-maria@linutronix.de
State New
Headers
Series timer: Move from a push remote at enqueue to a pull at expiry model |

Commit Message

Anna-Maria Behnsen Nov. 4, 2022, 2:57 p.m. UTC 
  forward_and_idle_timer_bases() includes the functionality for getting the
next timer interrupt. To reuse it, it is splitted into an separate function
"get_next_timer_interrupt()".

This is preparatory work for the conversion of the NOHZ timer
placement to a pull at expiry time model. No functional change.

Signed-off-by: Anna-Maria Behnsen <anna-maria@linutronix.de>
---
v4: Fix typo in comment
---
 kernel/time/timer.c | 93 +++++++++++++++++++++++++--------------------
 1 file changed, 51 insertions(+), 42 deletions(-)

Comments

Frederic Weisbecker Nov. 7, 2022, 12:42 p.m. UTC | #1 
On Fri, Nov 04, 2022 at 03:57:30PM +0100, Anna-Maria Behnsen wrote:
> forward_and_idle_timer_bases() includes the functionality for getting the
> next timer interrupt. To reuse it, it is splitted into an separate function
> "get_next_timer_interrupt()".
> 
> This is preparatory work for the conversion of the NOHZ timer
> placement to a pull at expiry time model. No functional change.
> 
> Signed-off-by: Anna-Maria Behnsen <anna-maria@linutronix.de>
> ---
> v4: Fix typo in comment
> ---
>  kernel/time/timer.c | 93 +++++++++++++++++++++++++--------------------
>  1 file changed, 51 insertions(+), 42 deletions(-)
> 
> diff --git a/kernel/time/timer.c b/kernel/time/timer.c
> index 680a0760e30d..853089febf83 100644
> --- a/kernel/time/timer.c
> +++ b/kernel/time/timer.c
> @@ -1704,6 +1704,46 @@ static unsigned long next_timer_interrupt(struct timer_base *base)
>  	return base->next_expiry;
>  }
>  
> +static unsigned long get_next_timer_interrupt(struct timer_base *base_local,

So perhaps forward_and_idle_timer_interrupt() could stay as
"get_next_timer_interrupt()" and the new get_next_timer_interrupt() above could
become fetch_next_timer_interrupt().

Just an idea.

From a functional POV:

     Reviewed-by: Frederic Weisbecker <frederic@kernel.org>

Thanks.
Anna-Maria Behnsen Nov. 8, 2022, 3:30 p.m. UTC | #2 
On Mon, 7 Nov 2022, Frederic Weisbecker wrote:

> On Fri, Nov 04, 2022 at 03:57:30PM +0100, Anna-Maria Behnsen wrote:
> > forward_and_idle_timer_bases() includes the functionality for getting the
> > next timer interrupt. To reuse it, it is splitted into an separate function
> > "get_next_timer_interrupt()".
> > 
> > This is preparatory work for the conversion of the NOHZ timer
> > placement to a pull at expiry time model. No functional change.
> > 
> > Signed-off-by: Anna-Maria Behnsen <anna-maria@linutronix.de>
> > ---
> > v4: Fix typo in comment
> > ---
> >  kernel/time/timer.c | 93 +++++++++++++++++++++++++--------------------
> >  1 file changed, 51 insertions(+), 42 deletions(-)
> > 
> > diff --git a/kernel/time/timer.c b/kernel/time/timer.c
> > index 680a0760e30d..853089febf83 100644
> > --- a/kernel/time/timer.c
> > +++ b/kernel/time/timer.c
> > @@ -1704,6 +1704,46 @@ static unsigned long next_timer_interrupt(struct timer_base *base)
> >  	return base->next_expiry;
> >  }
> >  
> > +static unsigned long get_next_timer_interrupt(struct timer_base *base_local,
> 
> So perhaps forward_and_idle_timer_interrupt() could stay as
> "get_next_timer_interrupt()" and the new get_next_timer_interrupt() above could
> become fetch_next_timer_interrupt().
> 
> Just an idea.

Hmm... it's better than mine :) I know, forward_and_idle_timer_bases() is
not the best name.

Maybe, it is total irrelevant: Since local and global timer information is
required, the original get_next_timer_interrupt() does not return directly
the next timer interrupt. This was introduced already in patch "timer:
Retrieve next expiry of pinned/non-pinned timers seperately". So it's no
longer possible to write:

	next_timer = get_next_timer_interrupt()

When having a function "get_something()" I would expect the information is
returned directly. Perhaps just a thing that I would expect... the new
get_next_timer_interrupt() returns directly the next timer interrupt.

Thanks,

	Anna-Maria
diff mbox series

Patch

diff --git a/kernel/time/timer.c b/kernel/time/timer.c
index 680a0760e30d..853089febf83 100644
--- a/kernel/time/timer.c
+++ b/kernel/time/timer.c
@@ -1704,6 +1704,46 @@  static unsigned long next_timer_interrupt(struct timer_base *base)
 	return base->next_expiry;
 }
 
+static unsigned long get_next_timer_interrupt(struct timer_base *base_local,
+					      struct timer_base *base_global,
+					      unsigned long basej, u64 basem,
+					      struct timer_events *tevt)
+{
+	unsigned long nextevt_local, nextevt_global;
+	bool local_first;
+
+	nextevt_local = next_timer_interrupt(base_local);
+	nextevt_global = next_timer_interrupt(base_global);
+
+	/*
+	 * Check whether the local event is expiring before or at the same
+	 * time as the global event.
+	 *
+	 * Note, that nextevt_global and nextevt_local might be based on
+	 * different base->clk values. So it's not guaranteed that
+	 * comparing with empty bases results in a correct local_first.
+	 */
+	if (base_local->timers_pending && base_global->timers_pending)
+		local_first = time_before_eq(nextevt_local, nextevt_global);
+	else
+		local_first = base_local->timers_pending;
+
+	/*
+	 * Update tevt->* values:
+	 *
+	 * If the local queue expires first, then the global event can
+	 * be ignored. If the global queue is empty, nothing to do
+	 * either.
+	 */
+	if (!local_first && base_global->timers_pending)
+		tevt->global = basem + (u64)(nextevt_global - basej) * TICK_NSEC;
+
+	if (base_local->timers_pending)
+		tevt->local = basem + (u64)(nextevt_local - basej) * TICK_NSEC;
+
+	return local_first ? nextevt_local : nextevt_global;
+}
+
 /*
  * Forward base clock is done only when @basej is past base->clk, otherwise
  * base-clk might be rewind.
@@ -1738,7 +1778,7 @@  void forward_and_idle_timer_bases(unsigned long basej, u64 basem,
 {
 	unsigned long nextevt, nextevt_local, nextevt_global;
 	struct timer_base *base_local, *base_global;
-	bool local_first, is_idle;
+	bool is_idle;
 
 	/* Preset local / global events */
 	tevt->local = tevt->global = KTIME_MAX;
@@ -1756,8 +1796,11 @@  void forward_and_idle_timer_bases(unsigned long basej, u64 basem,
 	raw_spin_lock(&base_local->lock);
 	raw_spin_lock_nested(&base_global->lock, SINGLE_DEPTH_NESTING);
 
-	nextevt_local = next_timer_interrupt(base_local);
-	nextevt_global = next_timer_interrupt(base_global);
+	nextevt = get_next_timer_interrupt(base_local, base_global,
+					   basej, basem, tevt);
+
+	nextevt_local = base_local->next_expiry;
+	nextevt_global = base_global->next_expiry;
 
 	/*
 	 * We have a fresh next event. Check whether we can forward the
@@ -1766,21 +1809,6 @@  void forward_and_idle_timer_bases(unsigned long basej, u64 basem,
 	forward_base_clk(base_local, nextevt_local, basej);
 	forward_base_clk(base_global, nextevt_global, basej);
 
-	/*
-	 * Check whether the local event is expiring before or at the same
-	 * time as the global event.
-	 *
-	 * Note, that nextevt_global and nextevt_local might be based on
-	 * different base->clk values. So it's not guaranteed that
-	 * comparing with empty bases results in a correct local_first.
-	 */
-	if (base_local->timers_pending && base_global->timers_pending)
-		local_first = time_before_eq(nextevt_local, nextevt_global);
-	else
-		local_first = base_local->timers_pending;
-
-	nextevt = local_first ? nextevt_local : nextevt_global;
-
 	/*
 	 * Bases are idle if the next event is more than a tick away. Also
 	 * the tick is stopped so any added timer must forward the base clk
@@ -1793,43 +1821,24 @@  void forward_and_idle_timer_bases(unsigned long basej, u64 basem,
 	/* We need to mark both bases in sync */
 	base_local->is_idle = base_global->is_idle = is_idle;
 
+	raw_spin_unlock(&base_global->lock);
+	raw_spin_unlock(&base_local->lock);
+
 	/*
 	 * If the bases are not marked idle, i.e one of the events is at
 	 * max. one tick away, then the CPU can't go into a NOHZ idle
 	 * sleep. Use the earlier event of both and store it in the local
 	 * expiry value. The next global event is irrelevant in this case
-	 * and can be left as KTIME_MAX. CPU will wakeup on time.
+	 * and can be reset as KTIME_MAX. CPU will wakeup on time.
 	 */
 	if (!is_idle) {
 		/* If we missed a tick already, force 0 delta */
 		if (time_before(nextevt, basej))
 			nextevt = basej;
 		tevt->local = basem + (u64)(nextevt - basej) * TICK_NSEC;
-		goto unlock;
+		tevt->global = KTIME_MAX;
 	}
 
-	/*
-	 * If the bases are marked idle, i.e. the next event on both the
-	 * local and the global queue are farther away than a tick,
-	 * evaluate both bases. No need to check whether one of the bases
-	 * has an already expired timer as this is caught by the !is_idle
-	 * condition above.
-	 */
-	if (base_local->timers_pending)
-		tevt->local = basem + (u64)(nextevt_local - basej) * TICK_NSEC;
-
-	/*
-	 * If the local queue expires first, then the global event can be
-	 * ignored. The CPU wakes up before that. If the global queue is
-	 * empty, nothing to do either.
-	 */
-	if (!local_first && base_global->timers_pending)
-		tevt->global = basem + (u64)(nextevt_global - basej) * TICK_NSEC;
-
-unlock:
-	raw_spin_unlock(&base_global->lock);
-	raw_spin_unlock(&base_local->lock);
-
 	cmp_next_hrtimer_event(basem, tevt);
 }