rtla/timerlat: Give timerlat auto analysis its own instance

Currently, the auto-analysis is attached to the timerlat top instance.
The idea was to avoid creating another instance just for that, so one
instance could be reused.

The drawback is that, by doing so, the auto-analysis run for the entire
session, consuming CPU time. On my 24 box CPUs for timerlat with a 100
us period consumed 50 % with auto analysis, but only 16 % without.

By creating an instance for auto-analysis, we can keep the processing
stopped until a stop tracing condition is hit. Once it happens,
timerlat auto-analysis can use its own trace instance to parse only
the end of the trace.

By doing so, auto-analysis stop consuming cpu time when it is not
needed.

If the --aa-only is passed, the timerlat top instance is reused for
auto analysis.

Link: https://lkml.kernel.org/r/346b7168c1bae552a415715ec6d23c129a43bdb7.1686066600.git.bristot@kernel.org
Cc: William White <chwhite@redhat.com>
Cc: Jonathan Corbet <corbet@lwn.net>
Tested-by: Juri Lelli <juri.lelli@redhat.com>
Signed-off-by: Daniel Bristot de Oliveira <bristot@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/tools/tracing/rtla/src/timerlat_aa.c b/tools/tracing/rtla/src/timerlat_aa.c
index 1843fff66da5b959e9a4bdca7a2663e1f96796e6..e0ffe69c271c6aa84e59bc6f635ebad5b369773d 100644 (file)
--- a/tools/tracing/rtla/src/timerlat_aa.c
+++ b/tools/tracing/rtla/src/timerlat_aa.c
@@ -8,6 +8,7 @@
 #include "utils.h"
 #include "osnoise.h"
 #include "timerlat.h"
+#include <unistd.h>
 
 enum timelat_state {
        TIMERLAT_INIT = 0,
@@ -233,7 +234,7 @@ static int timerlat_aa_thread_latency(struct timerlat_aa_data *taa_data,
  *
  * Returns 0 on success, -1 otherwise.
  */
-int timerlat_aa_handler(struct trace_seq *s, struct tep_record *record,
+static int timerlat_aa_handler(struct trace_seq *s, struct tep_record *record,
                        struct tep_event *event, void *context)
 {
        struct timerlat_aa_context *taa_ctx = timerlat_aa_get_ctx();
@@ -665,6 +666,25 @@ print_total:
                ns_to_usf(total));
 }
 
+static int timerlat_auto_analysis_collect_trace(struct timerlat_aa_context *taa_ctx)
+{
+       struct trace_instance *trace = &taa_ctx->tool->trace;
+       int retval;
+
+       retval = tracefs_iterate_raw_events(trace->tep,
+                                           trace->inst,
+                                           NULL,
+                                           0,
+                                           collect_registered_events,
+                                           trace);
+               if (retval < 0) {
+                       err_msg("Error iterating on events\n");
+                       return 0;
+               }
+
+       return 1;
+}
+
 /**
  * timerlat_auto_analysis - Analyze the collected data
  */
@@ -677,6 +697,8 @@ void timerlat_auto_analysis(int irq_thresh, int thread_thresh)
        struct tep_handle *tep;
        int cpu;
 
+       timerlat_auto_analysis_collect_trace(taa_ctx);
+
        /* bring stop tracing to the ns scale */
        irq_thresh = irq_thresh * 1000;
        thread_thresh = thread_thresh * 1000;
@@ -838,6 +860,10 @@ out_err:
  */
 static void timerlat_aa_unregister_events(struct osnoise_tool *tool, int dump_tasks)
 {
+
+       tep_unregister_event_handler(tool->trace.tep, -1, "ftrace", "timerlat",
+                                    timerlat_aa_handler, tool);
+
        tracefs_event_disable(tool->trace.inst, "osnoise", NULL);
 
        tep_unregister_event_handler(tool->trace.tep, -1, "osnoise", "nmi_noise",
@@ -875,6 +901,10 @@ static int timerlat_aa_register_events(struct osnoise_tool *tool, int dump_tasks
 {
        int retval;
 
+       tep_register_event_handler(tool->trace.tep, -1, "ftrace", "timerlat",
+                               timerlat_aa_handler, tool);
+
+
        /*
         * register auto-analysis handlers.
         */
@@ -955,8 +985,9 @@ out_ctx:
  *
  * Returns 0 on success, -1 otherwise.
  */
-int timerlat_aa_init(struct osnoise_tool *tool, int nr_cpus, int dump_tasks)
+int timerlat_aa_init(struct osnoise_tool *tool, int dump_tasks)
 {
+       int nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
        struct timerlat_aa_context *taa_ctx;
        int retval;
 

diff --git a/tools/tracing/rtla/src/timerlat_aa.h b/tools/tracing/rtla/src/timerlat_aa.h
index d4f6ca7e342a1d6a7f61f3f51357fc5a5a9f2f09..cea4bb1531a89d0b9daa9a6c680884d340caf33a 100644 (file)
--- a/tools/tracing/rtla/src/timerlat_aa.h
+++ b/tools/tracing/rtla/src/timerlat_aa.h
@@ -3,10 +3,7 @@
  * Copyright (C) 2023 Red Hat Inc, Daniel Bristot de Oliveira <bristot@kernel.org>
  */
 
-int timerlat_aa_init(struct osnoise_tool *tool, int nr_cpus, int dump_task);
+int timerlat_aa_init(struct osnoise_tool *tool, int dump_task);
 void timerlat_aa_destroy(void);
 
-int timerlat_aa_handler(struct trace_seq *s, struct tep_record *record,
-                       struct tep_event *event, void *context);
-
 void timerlat_auto_analysis(int irq_thresh, int thread_thresh);

diff --git a/tools/tracing/rtla/src/timerlat_top.c b/tools/tracing/rtla/src/timerlat_top.c
index f0c6d9735e2ad7a7e11cc892c6f8530ef62125d8..d6b5a382569ec64a771fa617b0139678c5d79654 100644 (file)
--- a/tools/tracing/rtla/src/timerlat_top.c
+++ b/tools/tracing/rtla/src/timerlat_top.c
@@ -156,9 +156,6 @@ timerlat_top_handler(struct trace_seq *s, struct tep_record *record,
                timerlat_top_update(top, cpu, thread, latency);
        }
 
-       if (!params->no_aa)
-               timerlat_aa_handler(s, record, event, context);
-
        return 0;
 }
 
@@ -644,7 +641,6 @@ static struct osnoise_tool
 {
        struct osnoise_tool *top;
        int nr_cpus;
-       int retval;
 
        nr_cpus = sysconf(_SC_NPROCESSORS_CONF);
 
@@ -661,16 +657,6 @@ static struct osnoise_tool
        tep_register_event_handler(top->trace.tep, -1, "ftrace", "timerlat",
                                   timerlat_top_handler, top);
 
-       /*
-        * If no auto analysis, we are ready.
-        */
-       if (params->no_aa)
-               return top;
-
-       retval = timerlat_aa_init(top, nr_cpus, params->dump_tasks);
-       if (retval)
-               goto out_err;
-
        return top;
 
 out_err:
@@ -702,6 +688,7 @@ int timerlat_top_main(int argc, char *argv[])
        struct timerlat_top_params *params;
        struct osnoise_tool *record = NULL;
        struct osnoise_tool *top = NULL;
+       struct osnoise_tool *aa = NULL;
        struct trace_instance *trace;
        int dma_latency_fd = -1;
        int return_value = 1;
@@ -774,6 +761,35 @@ int timerlat_top_main(int argc, char *argv[])
                trace_instance_start(&record->trace);
        }
 
+       if (!params->no_aa) {
+               if (params->aa_only) {
+                       /* as top is not used for display, use it for aa */
+                       aa = top;
+               } else  {
+                       /* otherwise, a new instance is needed */
+                       aa = osnoise_init_tool("timerlat_aa");
+                       if (!aa)
+                               goto out_top;
+               }
+
+               retval = timerlat_aa_init(aa, params->dump_tasks);
+               if (retval) {
+                       err_msg("Failed to enable the auto analysis instance\n");
+                       goto out_top;
+               }
+
+               /* if it is re-using the main instance, there is no need to start it */
+               if (aa != top) {
+                       retval = enable_timerlat(&aa->trace);
+                       if (retval) {
+                               err_msg("Failed to enable timerlat tracer\n");
+                               goto out_top;
+                       }
+
+                       trace_instance_start(&aa->trace);
+               }
+       }
+
        top->start_time = time(NULL);
        timerlat_top_set_signals(params);
 
@@ -829,13 +845,15 @@ int timerlat_top_main(int argc, char *argv[])
        }
 
 out_top:
+       timerlat_aa_destroy();
        if (dma_latency_fd >= 0)
                close(dma_latency_fd);
        trace_events_destroy(&record->trace, params->events);
        params->events = NULL;
 out_free:
        timerlat_free_top(top->data);
-       timerlat_aa_destroy();
+       if (aa && aa != top)
+               osnoise_destroy_tool(aa);
        osnoise_destroy_tool(record);
        osnoise_destroy_tool(top);
        free(params);