kevin/linux
1
Fork 0
Code

tick: Split nohz and highres features from nohz_mode

Browse Source 
The nohz mode field tells about low resolution nohz mode or high
resolution nohz mode but it doesn't tell about high resolution non-nohz
mode.

In order to retrieve the latter state, tick_cancel_sched_timer() must
fiddle with struct hrtimer's internals to guess if the tick has been
initialized in high resolution.

Move instead the nohz mode field information into the tick flags and
provide two new bits: one to know if the tick is in nohz mode and
another one to know if the tick is in high resolution. The combination
of those two flags provides all the needed informations to determine
which of the three tick modes is running.

Signed-off-by: Frederic Weisbecker <frederic@kernel.org>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Link: https://lore.kernel.org/r/20240225225508.11587-14-frederic@kernel.org
This commit is contained in:
Frederic Weisbecker 2024-02-25 23:55:05 +01:00 committed by Thomas Gleixner
parent a478ffb2ae
commit 7988e5ae2b
4 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
kernel/time/hrtimer.c
View File

@ -747,7 +747,7 @@ static void hrtimer_switch_to_hres(void)
base->hres_active = 1; base->hres_active = 1;
hrtimer_resolution = HIGH_RES_NSEC; hrtimer_resolution = HIGH_RES_NSEC;
tick_setup_sched_timer(NOHZ_MODE_HIGHRES); tick_setup_sched_timer(true);
/* "Retrigger" the interrupt to get things going */ /* "Retrigger" the interrupt to get things going */
retrigger_next_event(NULL); retrigger_next_event(NULL);
} }

32
kernel/time/tick-sched.c
View File

@ -831,7 +831,7 @@ static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)
/* Forward the time to expire in the future */ /* Forward the time to expire in the future */
hrtimer_forward(&ts->sched_timer, now, TICK_NSEC); hrtimer_forward(&ts->sched_timer, now, TICK_NSEC);
if (ts->nohz_mode == NOHZ_MODE_HIGHRES) { if (tick_sched_flag_test(ts, TS_FLAG_HIGHRES)) {
hrtimer_start_expires(&ts->sched_timer, hrtimer_start_expires(&ts->sched_timer,
HRTIMER_MODE_ABS_PINNED_HARD); HRTIMER_MODE_ABS_PINNED_HARD);
} else { } else {
@ -1040,14 +1040,14 @@ static void tick_nohz_stop_tick(struct tick_sched *ts, int cpu)
* the tick timer. * the tick timer.
*/ */
if (unlikely(expires == KTIME_MAX)) { if (unlikely(expires == KTIME_MAX)) {
if (ts->nohz_mode == NOHZ_MODE_HIGHRES) if (tick_sched_flag_test(ts, TS_FLAG_HIGHRES))
hrtimer_cancel(&ts->sched_timer); hrtimer_cancel(&ts->sched_timer);
else else
tick_program_event(KTIME_MAX, 1); tick_program_event(KTIME_MAX, 1);
return; return;
} }
if (ts->nohz_mode == NOHZ_MODE_HIGHRES) { if (tick_sched_flag_test(ts, TS_FLAG_HIGHRES)) {
hrtimer_start(&ts->sched_timer, expires, hrtimer_start(&ts->sched_timer, expires,
HRTIMER_MODE_ABS_PINNED_HARD); HRTIMER_MODE_ABS_PINNED_HARD);
} else { } else {
@ -1108,7 +1108,7 @@ static void tick_nohz_full_update_tick(struct tick_sched *ts)
if (!tick_nohz_full_cpu(smp_processor_id())) if (!tick_nohz_full_cpu(smp_processor_id()))
return; return;
if (ts->nohz_mode == NOHZ_MODE_INACTIVE) if (!tick_sched_flag_test(ts, TS_FLAG_NOHZ))
return; return;
__tick_nohz_full_update_tick(ts, ktime_get()); __tick_nohz_full_update_tick(ts, ktime_get());
@ -1168,7 +1168,7 @@ static bool can_stop_idle_tick(int cpu, struct tick_sched *ts)
return false; return false;
} }
if (unlikely(ts->nohz_mode == NOHZ_MODE_INACTIVE)) if (unlikely(!tick_sched_flag_test(ts, TS_FLAG_NOHZ)))
return false; return false;
if (need_resched()) if (need_resched())
@ -1487,11 +1487,11 @@ static void tick_nohz_lowres_handler(struct clock_event_device *dev)
tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1); tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
} }
static inline void tick_nohz_activate(struct tick_sched *ts, int mode) static inline void tick_nohz_activate(struct tick_sched *ts)
{ {
if (!tick_nohz_enabled) if (!tick_nohz_enabled)
return; return;
ts->nohz_mode = mode; tick_sched_flag_set(ts, TS_FLAG_NOHZ);
/* One update is enough */ /* One update is enough */
if (!test_and_set_bit(0, &tick_nohz_active)) if (!test_and_set_bit(0, &tick_nohz_active))
timers_update_nohz(); timers_update_nohz();
@ -1512,7 +1512,7 @@ static void tick_nohz_switch_to_nohz(void)
* Recycle the hrtimer in 'ts', so we can share the * Recycle the hrtimer in 'ts', so we can share the
* highres code. * highres code.
*/ */
tick_setup_sched_timer(NOHZ_MODE_LOWRES); tick_setup_sched_timer(false);
} }
static inline void tick_nohz_irq_enter(void) static inline void tick_nohz_irq_enter(void)
@ -1540,7 +1540,7 @@ static inline void tick_nohz_irq_enter(void)
static inline void tick_nohz_switch_to_nohz(void) { } static inline void tick_nohz_switch_to_nohz(void) { }
static inline void tick_nohz_irq_enter(void) { } static inline void tick_nohz_irq_enter(void) { }
static inline void tick_nohz_activate(struct tick_sched *ts, int mode) { } static inline void tick_nohz_activate(struct tick_sched *ts) { }
#endif /* CONFIG_NO_HZ_COMMON */ #endif /* CONFIG_NO_HZ_COMMON */
@ -1567,15 +1567,17 @@ early_param("skew_tick", skew_tick);
* tick_setup_sched_timer - setup the tick emulation timer * tick_setup_sched_timer - setup the tick emulation timer
* @mode: tick_nohz_mode to setup for * @mode: tick_nohz_mode to setup for
*/ */
void tick_setup_sched_timer(int mode) void tick_setup_sched_timer(bool hrtimer)
{ {
struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched); struct tick_sched *ts = this_cpu_ptr(&tick_cpu_sched);
/* Emulate tick processing via per-CPU hrtimers: */ /* Emulate tick processing via per-CPU hrtimers: */
hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD); hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_HARD);
if (IS_ENABLED(CONFIG_HIGH_RES_TIMERS) && mode == NOHZ_MODE_HIGHRES) if (IS_ENABLED(CONFIG_HIGH_RES_TIMERS) && hrtimer) {
tick_sched_flag_set(ts, TS_FLAG_HIGHRES);
ts->sched_timer.function = tick_nohz_handler; ts->sched_timer.function = tick_nohz_handler;
}
/* Get the next period (per-CPU) */ /* Get the next period (per-CPU) */
hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update()); hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());
@ -1589,11 +1591,11 @@ void tick_setup_sched_timer(int mode)
} }
hrtimer_forward_now(&ts->sched_timer, TICK_NSEC); hrtimer_forward_now(&ts->sched_timer, TICK_NSEC);
if (IS_ENABLED(CONFIG_HIGH_RES_TIMERS) && mode == NOHZ_MODE_HIGHRES) if (IS_ENABLED(CONFIG_HIGH_RES_TIMERS) && hrtimer)
hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED_HARD); hrtimer_start_expires(&ts->sched_timer, HRTIMER_MODE_ABS_PINNED_HARD);
else else
tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1); tick_program_event(hrtimer_get_expires(&ts->sched_timer), 1);
tick_nohz_activate(ts, mode); tick_nohz_activate(ts);
} }
void tick_cancel_sched_timer(int cpu) void tick_cancel_sched_timer(int cpu)
@ -1602,7 +1604,7 @@ void tick_cancel_sched_timer(int cpu)
ktime_t idle_sleeptime, iowait_sleeptime; ktime_t idle_sleeptime, iowait_sleeptime;
unsigned long idle_calls, idle_sleeps; unsigned long idle_calls, idle_sleeps;
if (IS_ENABLED(CONFIG_HIGH_RES_TIMERS) && ts->sched_timer.base) if (tick_sched_flag_test(ts, TS_FLAG_HIGHRES))
hrtimer_cancel(&ts->sched_timer); hrtimer_cancel(&ts->sched_timer);
idle_sleeptime = ts->idle_sleeptime; idle_sleeptime = ts->idle_sleeptime;
@ -1652,7 +1654,7 @@ int tick_check_oneshot_change(int allow_nohz)
if (!test_and_clear_bit(0, &ts->check_clocks)) if (!test_and_clear_bit(0, &ts->check_clocks))
return 0; return 0;
if (ts->nohz_mode != NOHZ_MODE_INACTIVE) if (tick_sched_flag_test(ts, TS_FLAG_NOHZ))
return 0; return 0;
if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available()) if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())

13
kernel/time/tick-sched.h
View File

@ -14,12 +14,6 @@ struct tick_device {
enum tick_device_mode mode; enum tick_device_mode mode;
}; };
enum tick_nohz_mode {
NOHZ_MODE_INACTIVE,
NOHZ_MODE_LOWRES,
NOHZ_MODE_HIGHRES,
};
/* The CPU is in the tick idle mode */ /* The CPU is in the tick idle mode */
#define TS_FLAG_INIDLE BIT(0) #define TS_FLAG_INIDLE BIT(0)
/* The idle tick has been stopped */ /* The idle tick has been stopped */
@ -31,6 +25,10 @@ enum tick_nohz_mode {
#define TS_FLAG_IDLE_ACTIVE BIT(2) #define TS_FLAG_IDLE_ACTIVE BIT(2)
/* CPU was the last one doing do_timer before going idle */ /* CPU was the last one doing do_timer before going idle */
#define TS_FLAG_DO_TIMER_LAST BIT(3) #define TS_FLAG_DO_TIMER_LAST BIT(3)
/* NO_HZ is enabled */
#define TS_FLAG_NOHZ BIT(4)
/* High resolution tick mode */
#define TS_FLAG_HIGHRES BIT(5)
/** /**
* struct tick_sched - sched tick emulation and no idle tick control/stats * struct tick_sched - sched tick emulation and no idle tick control/stats
@ -84,7 +82,6 @@ struct tick_sched {
ktime_t idle_entrytime; ktime_t idle_entrytime;
/* Tick stop */ /* Tick stop */
enum tick_nohz_mode nohz_mode;
unsigned long last_jiffies; unsigned long last_jiffies;
u64 timer_expires_base; u64 timer_expires_base;
u64 timer_expires; u64 timer_expires;
@ -107,7 +104,7 @@ struct tick_sched {
extern struct tick_sched *tick_get_tick_sched(int cpu); extern struct tick_sched *tick_get_tick_sched(int cpu);
extern void tick_setup_sched_timer(int mode); extern void tick_setup_sched_timer(bool hrtimer);
#if defined CONFIG_NO_HZ_COMMON || defined CONFIG_HIGH_RES_TIMERS #if defined CONFIG_NO_HZ_COMMON || defined CONFIG_HIGH_RES_TIMERS
extern void tick_cancel_sched_timer(int cpu); extern void tick_cancel_sched_timer(int cpu);
#else #else

5
kernel/time/timer_list.c
View File

@ -152,7 +152,8 @@ static void print_cpu(struct seq_file *m, int cpu, u64 now)
{ {
struct tick_sched *ts = tick_get_tick_sched(cpu); struct tick_sched *ts = tick_get_tick_sched(cpu);
P(nohz_mode); P_flag(nohz, TS_FLAG_NOHZ);
P_flag(highres, TS_FLAG_HIGHRES);
P_ns(last_tick); P_ns(last_tick);
P_flag(tick_stopped, TS_FLAG_STOPPED); P_flag(tick_stopped, TS_FLAG_STOPPED);
P(idle_jiffies); P(idle_jiffies);
@ -259,7 +260,7 @@ static void timer_list_show_tickdevices_header(struct seq_file *m)
static inline void timer_list_header(struct seq_file *m, u64 now) static inline void timer_list_header(struct seq_file *m, u64 now)
{ {
SEQ_printf(m, "Timer List Version: v0.9\n"); SEQ_printf(m, "Timer List Version: v0.10\n");
SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES); SEQ_printf(m, "HRTIMER_MAX_CLOCK_BASES: %d\n", HRTIMER_MAX_CLOCK_BASES);
SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now); SEQ_printf(m, "now at %Ld nsecs\n", (unsigned long long)now);
SEQ_printf(m, "\n"); SEQ_printf(m, "\n");