tracing/osnoise: Add option to align tlat threads

Add an option called TIMERLAT_ALIGN to osnoise/options, together with a
corresponding setting osnoise/timerlat_align_us.

This option sets the alignment of wakeup times between different
timerlat threads, similarly to cyclictest's -A/--aligned option. If
TIMERLAT_ALIGN is set, the first thread that reaches the first cycle
records its first wake-up time. Each following thread sets its first
wake-up time to a fixed offset from the recorded time, and increments
it by the same offset.

Example:

osnoise/timerlat_period is set to 1000, osnoise/timerlat_align_us is
set to 20. There are four threads, on CPUs 1 to 4.

- CPU 4 enters first cycle first. The current time is 20000us, so
the wake-up of the first cycle is set to 21000us. This time is recorded.
- CPU 2 enter first cycle next. It reads the recorded time, increments
it to 21020us, and uses this value as its own wake-up time for the first
cycle.
- CPU 3 enters first cycle next. It reads the recorded time, increments
it to 21040 us, and uses the value as its own wake-up time.
- CPU 1 proceeds analogically.

In each next cycle, the wake-up time (called "absolute period" in
timerlat code) is incremented by the (relative) period of 1000us. Thus,
the wake-ups in the following cycles (provided the times are reached and
not in the past) will be as follows:

CPU 1		CPU 2		CPU 3	 	CPU 4
21080us		21020us		21040us		21000us
22080us		22020us		22040us		22000us
...		...		...		...

Even if any cycle is skipped due to e.g. the first cycle calculation
happening later, the alignment stays in place.

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Luis Goncalves <lgoncalv@redhat.com>
Cc: Costa Shulyupin <costa.shul@redhat.com>
Link: https://patch.msgid.link/20260416115942.544032-1-tglozar@redhat.com
Signed-off-by: Tomas Glozar <tglozar@redhat.com>
Reviewed-by: Wander Lairson Costa <wander@redhat.com>
Reviewed-by: Crystal Wood <crwood@redhat.com>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/trace_osnoise.c b/kernel/trace/trace_osnoise.c
index dee610e465b981c1a4dbfb525b9e738818eedcac..78a4ee2e9c05d67365d583236a56d9817fdba940 100644 (file)
--- a/kernel/trace/trace_osnoise.c
+++ b/kernel/trace/trace_osnoise.c
@@ -58,6 +58,7 @@ enum osnoise_options_index {
        OSN_PANIC_ON_STOP,
        OSN_PREEMPT_DISABLE,
        OSN_IRQ_DISABLE,
+       OSN_TIMERLAT_ALIGN,
        OSN_MAX
 };
 
@@ -66,7 +67,8 @@ static const char * const osnoise_options_str[OSN_MAX] = {
                                                        "OSNOISE_WORKLOAD",
                                                        "PANIC_ON_STOP",
                                                        "OSNOISE_PREEMPT_DISABLE",
-                                                       "OSNOISE_IRQ_DISABLE" };
+                                                       "OSNOISE_IRQ_DISABLE",
+                                                       "TIMERLAT_ALIGN" };
 
 #define OSN_DEFAULT_OPTIONS            0x2
 static unsigned long osnoise_options   = OSN_DEFAULT_OPTIONS;
@@ -250,6 +252,11 @@ struct timerlat_variables {
 
 static DEFINE_PER_CPU(struct timerlat_variables, per_cpu_timerlat_var);
 
+/*
+ * timerlat wake-up offset for next thread with TIMERLAT_ALIGN set.
+ */
+static atomic64_t align_next;
+
 /*
  * this_cpu_tmr_var - Return the per-cpu timerlat_variables on its relative CPU
  */
@@ -268,6 +275,7 @@ static inline void tlat_var_reset(void)
 
        /* Synchronize with the timerlat interfaces */
        mutex_lock(&interface_lock);
+
        /*
         * So far, all the values are initialized as 0, so
         * zeroing the structure is perfect.
@@ -278,6 +286,12 @@ static inline void tlat_var_reset(void)
                        hrtimer_cancel(&tlat_var->timer);
                memset(tlat_var, 0, sizeof(*tlat_var));
        }
+       /*
+        * Reset also align_next, to be filled by a new offset by the first timerlat
+        * thread that wakes up, if TIMERLAT_ALIGN is set.
+        */
+       atomic64_set(&align_next, 0);
+
        mutex_unlock(&interface_lock);
 }
 #else /* CONFIG_TIMERLAT_TRACER */
@@ -326,6 +340,7 @@ static struct osnoise_data {
        u64     stop_tracing_total;     /* stop trace in the final operation (report/thread) */
 #ifdef CONFIG_TIMERLAT_TRACER
        u64     timerlat_period;        /* timerlat period */
+       u64     timerlat_align_us;      /* timerlat alignment */
        u64     print_stack;            /* print IRQ stack if total > */
        int     timerlat_tracer;        /* timerlat tracer */
 #endif
@@ -338,6 +353,7 @@ static struct osnoise_data {
 #ifdef CONFIG_TIMERLAT_TRACER
        .print_stack                    = 0,
        .timerlat_period                = DEFAULT_TIMERLAT_PERIOD,
+       .timerlat_align_us              = 0,
        .timerlat_tracer                = 0,
 #endif
 };
@@ -1829,6 +1845,26 @@ static int wait_next_period(struct timerlat_variables *tlat)
         */
        tlat->abs_period = (u64) ktime_to_ns(next_abs_period);
 
+       /*
+        * Align thread in the first cycle on each CPU to the set alignment
+        * if TIMERLAT_ALIGN is set.
+        *
+        * This is done by using an atomic64_t to store the next absolute period.
+        * The first thread that wakes up will set the atomic64_t to its
+        * absolute period, and the other threads will increment it by
+        * the alignment value.
+        */
+       if (test_bit(OSN_TIMERLAT_ALIGN, &osnoise_options) && !tlat->count
+           && atomic64_cmpxchg_relaxed(&align_next, 0, tlat->abs_period)) {
+               /*
+                * A thread has already set align_next, use it and increment it
+                * to be used by the next thread that wakes up after this one.
+                */
+               tlat->abs_period = atomic64_add_return_relaxed(
+                       osnoise_data.timerlat_align_us * 1000, &align_next);
+               next_abs_period = ns_to_ktime(tlat->abs_period);
+       }
+
        /*
         * If the new abs_period is in the past, skip the activation.
         */
@@ -2650,6 +2686,17 @@ static struct trace_min_max_param timerlat_period = {
        .min    = &timerlat_min_period,
 };
 
+/*
+ * osnoise/timerlat_align_us: align the first wakeup of all timerlat
+ * threads to a common boundary (in us). 0 means disabled.
+ */
+static struct trace_min_max_param timerlat_align_us = {
+       .lock   = &interface_lock,
+       .val    = &osnoise_data.timerlat_align_us,
+       .max    = NULL,
+       .min    = NULL,
+};
+
 static const struct file_operations timerlat_fd_fops = {
        .open           = timerlat_fd_open,
        .read           = timerlat_fd_read,
@@ -2746,6 +2793,11 @@ static int init_timerlat_tracefs(struct dentry *top_dir)
        if (!tmp)
                return -ENOMEM;
 
+       tmp = tracefs_create_file("timerlat_align_us", TRACE_MODE_WRITE, top_dir,
+                                 &timerlat_align_us, &trace_min_max_fops);
+       if (!tmp)
+               return -ENOMEM;
+
        retval = osnoise_create_cpu_timerlat_fd(top_dir);
        if (retval)
                return retval;