From bb3a47fd55929bbeef0a6dfdef1017391d5b7425 Mon Sep 17 00:00:00 2001 From: Jonathan Date: Mon, 5 Mar 2012 23:01:14 -0500 Subject: rt-graph: simple real-time task plots --- rt-graph.c | 99 ++++++++++++++++++ rt-graph.h | 19 +++- rt-plot-task.c | 293 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- rt-plot-task.h | 12 +-- trace-graph.h | 15 +++ trace-plot-cpu.c | 12 --- trace-plot-task.c | 25 +++-- trace-plot-task.h | 9 +- 8 files changed, 439 insertions(+), 45 deletions(-) diff --git a/rt-graph.c b/rt-graph.c index 71f2033..06fb6ab 100644 --- a/rt-graph.c +++ b/rt-graph.c @@ -11,6 +11,7 @@ #else #define dprintf(l, x...) do { if (0) printf(x); } while (0) #endif + /** * rt_graph_check_task_param - check for litmus_task_param record * Return 1 and @pid, @wcet, and @period if the record matches @@ -61,6 +62,94 @@ int rt_graph_check_task_param(struct rt_graph_info *rtinfo, return ret; } +/** + * rt_graph_check_task_switch_to - check for litmus_task_switch_to record + * Return 1 and @pid, @job, and @when if the record matches + */ +int rt_graph_check_task_switch_to(struct rt_graph_info *rtinfo, + struct pevent *pevent, struct record *record, + gint *pid, gint *job, + unsigned long long *when) +{ + struct event_format *event; + unsigned long long val; + gint id; + int ret = 0; + + if (rtinfo->task_switch_to_id < 0) { + event = pevent_find_event_by_name(pevent, "litmus", + "litmus_task_switch_to"); + if (!event) + goto out; + rtinfo->task_switch_to_id = event->id; + dprintf(2, "Found task_switch_to id %d\n", event->id); + rtinfo->switch_to_pid_field = pevent_find_field(event, "pid"); + rtinfo->switch_to_job_field = pevent_find_field(event, "job"); + rtinfo->switch_to_when_field = pevent_find_field(event, "when"); + } + + id = pevent_data_type(pevent, record); + if (id == rtinfo->task_switch_to_id) { + pevent_read_number_field(rtinfo->switch_to_pid_field, + record->data, &val); + *pid = val; + pevent_read_number_field(rtinfo->switch_to_job_field, + record->data, &val); + *job = val; + pevent_read_number_field(rtinfo->switch_to_when_field, + record->data, when); + ret = 1; + dprintf(3, "Read task_switch_to (%d) record for job %d:%d, " + "when: %llu\n", id, *pid, *job, *when); + } + out: + return ret; +} + +/** + * rt_graph_check_task_switch_away - check for litmus_task_switch_away record + * Return 1 and @pid, @job, and @when if the record matches + */ +int rt_graph_check_task_switch_away(struct rt_graph_info *rtinfo, + struct pevent *pevent, struct record *record, + gint *pid, gint *job, + unsigned long long *when) +{ + struct event_format *event; + unsigned long long val; + gint id; + int ret = 0; + + if (rtinfo->task_switch_away_id < 0) { + event = pevent_find_event_by_name(pevent, "litmus", + "litmus_task_switch_away"); + if (!event) + goto out; + rtinfo->task_switch_away_id = event->id; + dprintf(2, "Found task_switch_away id %d\n", event->id); + rtinfo->switch_away_pid_field = pevent_find_field(event, "pid"); + rtinfo->switch_away_job_field = pevent_find_field(event, "job"); + rtinfo->switch_away_when_field = pevent_find_field(event, "when"); + } + + id = pevent_data_type(pevent, record); + if (id == rtinfo->task_switch_away_id) { + pevent_read_number_field(rtinfo->switch_away_pid_field, + record->data, &val); + *pid = val; + pevent_read_number_field(rtinfo->switch_away_job_field, + record->data, &val); + *job = val; + pevent_read_number_field(rtinfo->switch_away_when_field, + record->data, when); + ret = 1; + dprintf(3, "Read task_switch_away (%d) record for job %d:%d, " + "when: %llu\n", id, *pid, *job, *when); + } + out: + return ret; +} + /** * rt_graph_check_task_release - check for litmus_task_release record * Return 1 and @pid, @job, and @deadline if the record matches @@ -236,6 +325,8 @@ void init_rt_event_cache(struct rt_graph_info *rtinfo) { dprintf(1, "Initializing RT event cache\n"); rtinfo->task_param_id = -1; + rtinfo->task_switch_to_id = -1; + rtinfo->task_switch_away = -1; rtinfo->task_release_id = -1; rtinfo->task_completion_id = -1; rtinfo->task_block_id = -1; @@ -245,6 +336,14 @@ void init_rt_event_cache(struct rt_graph_info *rtinfo) rtinfo->param_wcet_field = NULL; rtinfo->param_period_field = NULL; + rtinfo->switch_to_pid_field = NULL; + rtinfo->switch_to_job_field = NULL; + rtinfo->switch_to_when_field = NULL; + + rtinfo->switch_away_pid_field = NULL; + rtinfo->switch_away_job_field = NULL; + rtinfo->switch_away_when_field = NULL; + rtinfo->release_pid_field = NULL; rtinfo->release_job_field = NULL; rtinfo->release_release_field = NULL; diff --git a/rt-graph.h b/rt-graph.h index 3357b52..8fbe6f3 100644 --- a/rt-graph.h +++ b/rt-graph.h @@ -8,7 +8,7 @@ struct rt_graph_info { - /* List of all tasks */ + /* List of all real-time tasks */ struct task_list *tasks[TASK_HASH_SIZE]; /* Cache of event fields so that they don't need to be located @@ -19,6 +19,16 @@ struct rt_graph_info { struct format_field *param_wcet_field; struct format_field *param_period_field; + gint task_switch_to_id; + struct format_field *switch_to_pid_field; + struct format_field *switch_to_job_field; + struct format_field *switch_to_when_field; + + gint task_switch_away_id; + struct format_field *switch_to_pid_field; + struct format_field *switch_to_job_field; + struct format_field *switch_to_when_field; + gint task_release_id; struct format_field *release_pid_field; struct format_field *release_job_field; @@ -37,7 +47,6 @@ struct rt_graph_info { gint task_resume_id; struct format_field *resume_pid_field; struct format_field *resume_when_field; - }; /* Event parsers */ @@ -45,6 +54,12 @@ int rt_graph_check_task_param(struct rt_graph_info *rtinfo, struct pevent *peven struct record *record, gint *pid, unsigned long long *wcet, unsigned long long *period); +int rt_graph_check_task_switch_to(struct rt_graph_info *rtinfo, struct pevent *pevent, + struct record *record, gint *pid, gint *job, + unsigned long long *when); +int rt_graph_check_task_switch_away(struct rt_graph_info *rtinfo, struct pevent *pevent, + struct record *record, gint *pid, gint *job, + unsigned long long *when); int rt_graph_check_task_release(struct rt_graph_info *rtinfo, struct pevent *pevent, struct record *record, gint *pid, gint *job, unsigned long long *release, diff --git a/rt-plot-task.c b/rt-plot-task.c index d63c872..d1af3d6 100644 --- a/rt-plot-task.c +++ b/rt-plot-task.c @@ -1,13 +1,290 @@ #include "trace-graph.h" +#define LLABEL 30 + +/* Ok to do it this way as long as it remains single threaded */ +static void update_job(struct rt_task_info *rtt_info, int job) +{ + if (job < rtt_info->last_job) { + die("Inconsistent job state for %d:%d -> %d\n", + rtt_info->base.pid, rtt_info->last_job, job); + } + if (job > rtt_info->last_job) { + rtt_info->last_job = job; + snprintf(rtt_info->label, LLABEL, "%d:%d", + rtt_info->base.pid, rtt_info->last_job); + } +} + +static inline void create_job_label(char *label, int pid, int job) +{ + label = malloc_or_die(20); + snprintf(label, 20, "%d:%d", pid, job); +} + +static int try_param(struct graph_info *ginfo, struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, match, ret = 0; + unsigned long long wcet, period; + + /* Only 1 param record per event */ + if (rtt_info->params_found) + goto out; + + match = rt_graph_check_task_param(&ginfo->rtinfo, ginfo->pevent, + record, &pid, &wcet, &period); + if (match && pid == rtt_info->base.pid) { + rtt_info->wcet = wcet; + rtt_info->period = period; + rtt_info->params_found = TRUE; + update_job(rtt_info, 0); + ret = 1; + } + out: + return ret; +} + + +static int try_release(struct graph_info *ginfo, struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, job, match, ret = 0; + unsigned long long release, deadline; + + match = rt_graph_check_task_release(&ginfo->rtinfo, ginfo->pevent, + record, &pid, &job, + &release, &deadline); + if (match && pid == rtt_info->base.pid) { + info->release = TRUE; + info->rtime = release; + info->rlabel = rtt_info->label; + + info->deadline = TRUE; + info->dtime = deadline; + info->dlabel = rtt_info->label; + + update_job(rtt_info, job); + ret = 1; + } + return ret; +} + +static int try_completion(struct graph_info *ginfo, + struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, job, match, ret = 0; + unsigned long long when; + + match = rt_graph_check_task_completion(&ginfo->rtinfo, ginfo->pevent, + record, &pid, &job, &when); + if (match && pid == rtt_info->base.pid) { + info->completion = TRUE; + info->ctime = when; + info->clabel = rtt_info->label; + update_job(rtt_info, job); + ret = 1; + } + return ret; +} + +static int try_block(struct graph_info *ginfo, struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, match, ret = 0; + unsigned long long when; + + match = rt_graph_check_task_block(&ginfo->rtinfo, ginfo->pevent, + record, &pid, &when); + if (match && pid == rtt_info->base.pid) { + rtt_info->block_time = when; + ret = 1; + } + return ret; +} + +static int try_resume(struct graph_info *ginfo, struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, match, ret = 0; + unsigned long long when; + + match = rt_graph_check_task_resume(&ginfo->rtinfo, ginfo->pevent, + record, &pid, &when); + if (match && pid == rtt_info->base.pid) { + rtt_info->block_time = when; + info->box = TRUE; + info->bcolor = 0x0; + info->bfill = TRUE; + info->bthin = TRUE; + info->bstart = rtt_info->block_time; + info->bend = when; + + rtt_info->block_time = -1; + + ret = 1; + } + return ret; +} + +static int try_other(struct graph_info *ginfo, struct rt_task_info *rtt_info, + struct record *record, struct plot_info *info) +{ + int pid, is_sched, is_wakeup, rec_pid, sched_pid, match, ret = 0; + struct task_plot_info *task_info = &rtt_info->base; + + pid = task_info->pid; + match = record_matches_pid(ginfo, record, pid, &rec_pid, + &sched_pid, &is_sched, &is_wakeup); + if (match) { + info->line = TRUE; + info->lcolor = hash_pid(rec_pid); + info->ltime = record->ts; + ret = 1; + + update_last_task_record(ginfo, task_info, record); + + if (is_wakeup) { + /* Another task is running on this CPU now */ + info->ltime = hash_pid(rec_pid); + if (task_info->last_cpu == record->cpu) { + info->box = TRUE; + info->bcolor = hash_cpu(task_info->last_cpu); + info->bstart = task_info->last_time; + info->bend = record->ts; + task_info->last_cpu = -1; + } + goto out; + } + + if (task_info->last_cpu != record->cpu) { + /* Switched cpus */ + if (task_info->last_cpu >= 0) { + info->box = TRUE; + info->bcolor = hash_cpu(task_info->last_cpu); + info->bstart = task_info->last_time; + info->bend = record->ts; + } + task_info->last_time = record->ts; + } + + task_info->last_cpu = record->cpu; + if (is_sched) { + if (rec_pid != pid) { + /* Scheduled in */ + task_info->last_cpu = record->cpu; + task_info->last_time = record->ts; + } else if (!info->box) { + /* Scheduled out */ + info->box = TRUE; + info->bcolor = hash_cpu(task_info->last_cpu); + info->bstart = task_info->last_time; + info->bend = record->ts; + task_info->last_cpu = -1; + } + } + } + out: + if (info->box) { + info->blabel = rtt_info->label; + } + return ret; +} + +int rt_task_plot_event(struct graph_info *ginfo, struct graph_plot *plot, + struct record *record, struct plot_info *info) +{ + struct rt_task_info *rtt_info = plot->private; + struct task_plot_info *task_info = &rtt_info->base; + int match, cpu; + + /* No more records, finish what we started */ + if (!record) { + update_last_task_record(ginfo, task_info, record); + if (task_info->last_cpu >= 0) { + info->box = TRUE; + info->bstart = task_info->last_time; + info->bend = ginfo->view_end_time; + info->bcolor = hash_cpu(task_info->last_cpu); + } + for (cpu = 0; cpu < ginfo->cpus; cpu++) { + free_record(task_info->last_records[cpu]); + task_info->last_records[cpu] = NULL; + } + return 0; + } + + match = try_param(ginfo, rtt_info, record, info) || + try_release(ginfo, rtt_info, record, info) || + try_completion(ginfo, rtt_info, record, info) || + try_block(ginfo, rtt_info, record, info) || + try_resume(ginfo, rtt_info, record, info) || + try_other(ginfo, rtt_info, record, info); + + /* This record is neither on our CPU nor related to us, useless */ + if (!match && record->cpu != task_info->last_cpu) { + if (!task_info->last_records[record->cpu]) { + task_info->last_records[record->cpu] = record; + tracecmd_record_ref(record); + } + return 0; + } + + if (!match) { + cpu = record->cpu; + /* We need some record, use this if none exist */ + if (!task_info->last_records[cpu]) { + free_record(task_info->last_records[cpu]); + task_info->last_records[cpu] = record; + } + + /* We were on a CPU, now scheduled out */ + if (task_info->last_cpu >= 0) { + info->box = TRUE; + info->bcolor = hash_cpu(task_info->last_cpu); + info->bstart = task_info->last_time; + info->bend = record->ts; + task_info->last_cpu = -1; + } + } else { + update_last_task_record(ginfo, task_info, record); + } + out: + return 1; +} + +void rt_task_plot_start(struct graph_info *ginfo, struct graph_plot *plot, + unsigned long long time) +{ + struct rt_task_info *rtt_info = plot->private; + + task_plot_start(ginfo, plot, time); + + rtt_info->wcet = 0ULL; + rtt_info->period = 0ULL; + rtt_info->block_time = 0ULL; + rtt_info->last_job = -1; + rtt_info->params_found = FALSE; + update_job(rtt_info, 0); +} + +void rt_task_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot) +{ + struct rt_task_info *rtt_info = plot->private; + free(rtt_info->label); + task_plot_destroy(ginfo, plot); +} + static const struct plot_callbacks rt_task_cb = { + .plot_event = rt_task_plot_event, + .start = rt_task_plot_start, + .destroy = rt_task_plot_destroy, + .match_time = task_plot_match_time, - .plot_event = task_plot_event, - .start = task_plot_start, .display_last_event = task_plot_display_last_event, .find_record = task_plot_find_record, .display_info = task_plot_display_info, - .destroy = task_plot_destroy }; void rt_plot_task_update_callback(gboolean accept, @@ -27,7 +304,7 @@ void rt_plot_task_plotted(struct graph_info *ginfo, gint **plotted) void rt_plot_task(struct graph_info *ginfo, int pid, int pos) { struct rt_graph_info *rtinfo = &ginfo->rtinfo; - struct rt_task_info *rt_task; + struct rt_task_info *rtt_info; struct graph_plot *plot; const char *comm; char *label; @@ -36,9 +313,10 @@ void rt_plot_task(struct graph_info *ginfo, int pid, int pos) if (!find_task_list(rtinfo->tasks, pid)) die("Cannot create RT plot of non-RT task %d!\n", pid); - rt_task = malloc_or_die(sizeof(*rt_task)); + rtt_info = malloc_or_die(sizeof(*rtt_info)); + rtt_info->label = malloc_or_die(LLABEL); - init_task_plot_info(ginfo, &rt_task->base, TASK_PLOT_RT, pid); + init_task_plot_info(ginfo, &rtt_info->base, TASK_PLOT_RT, pid); comm = pevent_data_comm_from_pid(ginfo->pevent, pid); len = strlen(comm) + 100; @@ -46,9 +324,8 @@ void rt_plot_task(struct graph_info *ginfo, int pid, int pos) snprintf(label, len, "*%s-%d", comm, pid); plot = trace_graph_plot_insert(ginfo, pos, label, PLOT_TYPE_TASK, - &rt_task_cb, rt_task); + &rt_task_cb, rtt_info); free(label); trace_graph_plot_add_all_recs(ginfo, plot); } - diff --git a/rt-plot-task.h b/rt-plot-task.h index 4cb957a..a11d347 100644 --- a/rt-plot-task.h +++ b/rt-plot-task.h @@ -9,14 +9,12 @@ struct rt_task_info { unsigned long long period; unsigned long long block_time; int last_job; + gboolean params_found; + char *label; }; void rt_plot_task(struct graph_info *ginfo, int pid, int pos); -void rt_plot_task_plotted(struct graph_info *ginfo, - gint **plotted); -void rt_plot_task_update_callback(gboolean accept, - gint *selected, - gint *non_select, - gpointer data); - +void rt_plot_task_plotted(struct graph_info *ginfo, gint **plotted); +void rt_plot_task_update_callback(gboolean accept, gint *selected, + gint *non_select, gpointer data); #endif diff --git a/trace-graph.h b/trace-graph.h index a0c5c54..ee57be6 100644 --- a/trace-graph.h +++ b/trace-graph.h @@ -49,11 +49,26 @@ struct plot_info { gboolean line; int lcolor; unsigned long long ltime; + gboolean box; int bcolor; unsigned long long bstart; unsigned long long bend; gboolean bfill; + gboolean bthin; + char *blabel; + + gboolean release; + unsigned long long rtime; + char *rlabel; + + gboolean deadline; + unsigned long long dtime; + char *dlabel; + + gboolean completion; + unsigned long long ctime; + char *clabel; }; /* diff --git a/trace-plot-cpu.c b/trace-plot-cpu.c index c7a37f5..00f07af 100644 --- a/trace-plot-cpu.c +++ b/trace-plot-cpu.c @@ -80,12 +80,8 @@ static int filter_record(struct graph_info *ginfo, int wake_pid; int filter; gint rpid; - gint job; - unsigned long long release; - unsigned long long deadline; unsigned long long period; unsigned long long wcet; - unsigned long long when; *orig_pid = pevent_data_pid(ginfo->pevent, record); @@ -95,14 +91,6 @@ static int filter_record(struct graph_info *ginfo, /* Load real-time records */ rt_graph_check_task_param(&ginfo->rtinfo, ginfo->pevent, record, &rpid, &wcet, &period); - rt_graph_check_task_release(&ginfo->rtinfo, ginfo->pevent, record, - &rpid, &job, &release, &deadline); - rt_graph_check_task_completion(&ginfo->rtinfo, ginfo->pevent, record, - &rpid, &job, &when); - rt_graph_check_task_block(&ginfo->rtinfo, ginfo->pevent, record, - &rpid, &when); - rt_graph_check_task_resume(&ginfo->rtinfo, ginfo->pevent, record, - &rpid, &when); if (trace_graph_check_sched_switch(ginfo, record, sched_pid, &comm)) { is_sched_switch = TRUE; diff --git a/trace-plot-task.c b/trace-plot-task.c index e4ac13a..068fd91 100644 --- a/trace-plot-task.c +++ b/trace-plot-task.c @@ -40,10 +40,10 @@ gboolean is_running(struct graph_info *ginfo, struct record *record) } gboolean record_matches_pid(struct graph_info *ginfo, - struct record *record, int match_pid, - int *pid, int *sched_pid, - gboolean *is_sched, - gboolean *wakeup) + struct record *record, int match_pid, + int *pid, int *sched_pid, + gboolean *is_sched, + gboolean *wakeup) { const char *comm; @@ -208,9 +208,9 @@ find_record(struct graph_info *ginfo, gint pid, guint64 time) } int task_plot_display_last_event(struct graph_info *ginfo, - struct graph_plot *plot, - struct trace_seq *s, - unsigned long long time) + struct graph_plot *plot, + struct trace_seq *s, + unsigned long long time) { struct task_plot_info *task_info = plot->private; struct event_format *event; @@ -294,8 +294,8 @@ void task_plot_start(struct graph_info *ginfo, struct graph_plot *plot, } void update_last_task_record(struct graph_info *ginfo, - struct task_plot_info *task_info, - struct record *record) + struct task_plot_info *task_info, + struct record *record) { struct tracecmd_input *handle = ginfo->handle; struct record *trecord, *t2record; @@ -375,9 +375,9 @@ void update_last_task_record(struct graph_info *ginfo, } int task_plot_event(struct graph_info *ginfo, - struct graph_plot *plot, - struct record *record, - struct plot_info *info) + struct graph_plot *plot, + struct record *record, + struct plot_info *info) { struct task_plot_info *task_info = plot->private; gboolean match; @@ -409,7 +409,6 @@ int task_plot_event(struct graph_info *ginfo, match = record_matches_pid(ginfo, record, pid, &rec_pid, &sched_pid, &is_sched, &is_wakeup); - if (!match && record->cpu != task_info->last_cpu) { if (!task_info->last_records[record->cpu]) { task_info->last_records[record->cpu] = record; diff --git a/trace-plot-task.h b/trace-plot-task.h index 3232339..78ff68f 100644 --- a/trace-plot-task.h +++ b/trace-plot-task.h @@ -41,9 +41,9 @@ struct task_plot_info { /* Querying records */ gboolean is_running(struct graph_info *ginfo, struct record *record); -gboolean record_matches_pid(struct graph_info *ginfo, struct record *record, - int match_pid, int *pid, int *sched_pid, - gboolean *is_sched, gboolean *wakeup); +/* gboolean record_matches_pid(struct graph_info *ginfo, struct record *record, */ +/* int match_pid, int *pid, int *sched_pid, */ +/* gboolean *is_sched, gboolean *wakeup); */ /* State maintenance */ void update_last_task_record(struct graph_info *ginfo, struct task_plot_info *task_info, @@ -58,6 +58,9 @@ struct record *find_previous_record(struct graph_info *ginfo, int pid, int cpu); struct record *get_display_record(struct graph_info *ginfo, int pid, unsigned long long time); +gboolean record_matches_pid(struct graph_info *ginfo, struct record *record, + int match_pid, int *pid, int *sched_pid, + gboolean *is_sched, gboolean *wakeup); /* Seeking in data file */ void set_cpu_to_time(int cpu, struct graph_info *ginfo, unsigned long long time); -- cgit v1.2.2