containers: virtual cpus display in the normal case

9 files changed, 866 insertions, 3 deletions

diff --git a/rt-graph.h b/rt-graph.h
index 8252d61..12ce72d 100644
--- a/rt-graph.h
+++ b/rt-graph.h
@@ -10,7 +10,7 @@
 #include "rt-plot-container.h"
 
 #define LLABEL 30
-#define SEARCH_PERIODS 3
+#define SEARCH_PERIODS 1
 #define NO_CPU -1
 #define RT_TS_FIELD "__rt_ts"
 
diff --git a/rt-plot-container.c b/rt-plot-container.c
new file mode 100644
index 0000000..f36e2f8
--- /dev/null
+++ b/rt-plot-container.c
@@ -0,0 +1,374 @@
+#include <stdio.h>
+#include <string.h>
+#include "trace-graph.h"
+#include "trace-hash.h"
+#include "trace-filter.h"
+
+struct vtask_info {
+        struct rt_task_info     task_info;
+        struct cont_list        *cont;
+};
+
+static void insert_vtask(struct graph_info *ginfo, struct cont_list *cont,
+                         struct vcpu_list *vcpu_info)
+{
+        struct graph_plot *plot;
+        struct vtask_info *vtask;
+        char *label;
+        int len;
+
+        vtask = malloc_or_die(sizeof(*vtask));
+        vtask->task_info.pid = vcpu_info->sid;
+        vtask->task_info.wcet = vcpu_info->params.wcet;
+        vtask->task_info.period = vcpu_info->params.period;
+        vtask->task_info.label = malloc_or_die(LLABEL);
+        vtask->cont = cont;
+
+        g_assert(cont);
+
+        len = strlen(cont->name) + 100;
+        label = malloc_or_die(len);
+        snprintf(label, len, "%s-%d\n(%1.1f, %1.1f)",
+                 cont->name, -vtask->task_info.pid,
+                 nano_as_milli(vtask->task_info.wcet),
+                 nano_as_milli(vtask->task_info.period));
+
+        plot = trace_graph_plot_append(ginfo, label, PLOT_TYPE_SERVER_TASK,
+                                       TIME_TYPE_RT, &rt_task_cb, vtask);
+        trace_graph_plot_add_all_recs(ginfo, plot);
+}
+
+int rt_plot_get_containers(struct graph_info *ginfo, gint **conts,
+                            gboolean plotted_only)
+{
+        struct rt_graph_info *rtg_info = &ginfo->rtg_info;
+        struct cont_list *cont;
+        int i, count = 0;
+
+        *conts = NULL;
+        for (i = 0; i < CONT_HASH_SIZE; i++) {
+                for (cont = rtg_info->containers[i]; cont; cont = cont->next) {
+                        if (!plotted_only || cont->plotted) {
+                                trace_array_add(conts, &count, cont->cid);
+                        }
+                }
+        }
+        return count;
+}
+
+int get_server_info(struct graph_info *ginfo, struct rt_plot_common *rt,
+                    int match_sid, unsigned long long time,
+                    unsigned long long *out_release,
+                    unsigned long long *out_deadline,
+                    int *out_job, int *out_tid,
+                    struct record **out_record)
+{
+        struct record *record;
+        int sid, job, tid, match, next_cpu, is_running = 0;
+        unsigned long long when, max_ts;
+
+        *out_record = find_rt_record(ginfo, rt, time);
+        if (!(*out_record))
+                return 0;
+
+        *out_release = *out_deadline = *out_job = *out_tid = 0;
+
+        /* Get current job info for server task */
+        get_previous_release(ginfo, sid, time,
+                             out_job, out_release, out_deadline);
+
+        /* Need to reset back to current location */
+        record = find_rt_record(ginfo, rt, time);
+        if (!record)
+                goto out;
+
+        /* TODO: read backwards too */
+        max_ts = time + max_rt_search(ginfo);
+        do {
+                if (get_rts(ginfo, record) > max_ts)
+                        break;
+
+                match = rt_graph_check_server_switch_away(ginfo, record,
+                                                          &sid, &job, &tid,
+                                                          &when);
+                if (match && sid == match_sid) {
+                        *out_tid = tid;
+                        is_running = 1;
+                        break;
+                }
+                free_record(record);
+        } while ((record = tracecmd_read_next_data(ginfo->handle, &next_cpu)));
+
+        if (record && record != *out_record)
+                free_record(record);
+ out:
+        return is_running;
+}
+
+void rt_plot_container(struct graph_info *ginfo, int cid)
+{
+        struct cont_list *cont;
+        struct vcpu_list *vlist;
+        struct rt_graph_info *rtg_info = &ginfo->rtg_info;
+        int key;
+
+        key  = get_container_key(cid);
+        cont = find_container(rtg_info->containers, cid, key);
+        if (!cont)
+                die("Cannot create plot of non-existent container %d!\n", cid);
+        if (!cont->vcpus)
+                die("Cannot plot container %d with no vcpus!\n", cid);
+
+        cont->plotted = TRUE;
+
+        for (vlist = cont->vcpus; vlist; vlist = vlist->next) {
+                /* insert_vtask(ginfo, cont, vlist); */
+                insert_vcpu(ginfo, cont, vlist);
+        }
+}
+
+void rt_plot_add_all_containers(struct graph_info *ginfo)
+{
+        struct cont_list *cont, **conts;
+        int i;
+
+        conts = ginfo->rtg_info.containers;
+        for (i = 0; i < CONT_HASH_SIZE; i++) {
+                for (cont = *conts; cont; cont = cont->next) {
+                        rt_plot_container(ginfo, cont->cid);
+                }
+        }
+}
+
+struct cont_filter_helper {
+        gboolean        all_conts;
+        GtkWidget       **buttons;
+        int             *conts;
+        gboolean        *selected;
+        int             num_conts;
+};
+
+#define ALL_CONTS_STR "All Containers"
+#define DIALOG_WIDTH    400
+#define DIALOG_HEIGHT   600
+
+static void cont_toggle(gpointer data, GtkWidget *widget)
+{
+        struct cont_filter_helper *helper = data;
+        const gchar *label;
+        gboolean active;
+        int cont;
+
+        label = gtk_button_get_label(GTK_BUTTON(widget));
+        active = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
+
+        if (strcmp(label, ALL_CONTS_STR) == 0) {
+                helper->all_conts = active;
+                if (active) {
+                        for (cont = 0; cont < helper->num_conts; cont++) {
+                                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(helper->buttons[cont]),
+                                                             TRUE);
+                        }
+                }
+        }
+
+        for (cont = 0; cont < helper->num_conts; cont++) {
+                if (helper->buttons[cont] == widget) {
+                        helper->selected[cont] = active;
+                }
+        }
+}
+
+
+
+static void do_container_filter(struct graph_info *ginfo,
+                                struct cont_filter_helper *helper, gpointer data)
+{
+        struct graph_plot *plot;
+        struct vtask_info *vtask;
+        struct vcpu_info *vcpu;
+        struct cont_list *cont;
+        int i, c, *append;
+
+        append = malloc_or_die(helper->num_conts * sizeof(gint));
+        for (i = 0; i < helper->num_conts; i++)
+                append[i] = helper->selected[i];
+
+        for (i = ginfo->plots - 1; i >= 0; i--) {
+                plot = ginfo->plot_array[i];
+
+                if (plot->type != PLOT_TYPE_SERVER_TASK &&
+                    plot->type != PLOT_TYPE_SERVER_CPU)
+                        continue;
+
+                if (plot->type == PLOT_TYPE_SERVER_TASK) {
+                        vtask = plot->private;
+                        cont = vtask->cont;
+                } else {
+                        vcpu = plot->private;
+                        cont = vcpu->cont;
+                }
+
+                for (c = 0; c < helper->num_conts; c++) {
+                        if (helper->conts[c] == cont->cid)
+                                break;
+                }
+                if (c > helper->num_conts)
+                        continue;
+
+                if (helper->selected[c]) {
+                        append[c] = FALSE;
+                } else {
+                        cont->plotted = FALSE;
+                        trace_graph_plot_remove(ginfo, plot);
+                }
+        }
+
+        /* Add new plots */
+        for (c = 0; c < helper->num_conts; c++) {
+                if (append[c])
+                        rt_plot_container(ginfo, helper->conts[c]);
+        }
+        trace_graph_refresh(ginfo);
+}
+
+void trace_container_dialog(struct graph_info *ginfo,
+                            gpointer data)
+{
+        GtkWidget *dialog, *scrollwin, *viewport, *hbox, *vbox, *check, *twidget;
+        GtkRequisition req;
+        struct tracecmd_input *handle;
+        struct pevent *pevent;
+        struct cont_filter_helper *cont_helper;
+        struct cont_list *cont;
+        gchar label[100];
+        gint *selected, *conts;
+        gboolean tbool;
+        int i, result, cont_num, height, width, cont_count, select_count;
+        int start, min_cont, tint;
+
+        handle = ginfo->handle;
+        if (!handle)
+                return;
+        pevent = tracecmd_get_pevent(handle);
+        if (!pevent)
+                return;
+
+        select_count = rt_plot_get_containers(ginfo, &selected, TRUE);
+        free(selected);
+        cont_count = rt_plot_get_containers(ginfo, &conts, FALSE);
+
+        /* Create helper */
+        cont_helper = g_new0(typeof(*cont_helper), 1);
+        cont_helper->num_conts = cont_count;
+        cont_helper->buttons = g_new0(GtkWidget*, cont_count + 1);
+        cont_helper->conts = conts;
+        cont_helper->selected = g_new0(gint, cont_count);
+
+        /* Create dialog window */
+        dialog = gtk_dialog_new_with_buttons("Select Containers", NULL,
+                                             GTK_DIALOG_MODAL, "Apply",
+                                             GTK_RESPONSE_ACCEPT,
+                                             GTK_STOCK_CANCEL,
+                                             GTK_RESPONSE_REJECT, NULL);
+        scrollwin = gtk_scrolled_window_new(NULL, NULL);
+        gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
+                                       GTK_POLICY_AUTOMATIC,
+                                       GTK_POLICY_AUTOMATIC);
+        viewport = gtk_viewport_new(NULL, NULL);
+        gtk_widget_show(viewport);
+
+        /* Create scroll area */
+        gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
+        gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwin, TRUE, TRUE, 0);
+        hbox = gtk_hbox_new(FALSE, 0);
+        gtk_container_add(GTK_CONTAINER(viewport), hbox);
+        gtk_widget_show(hbox);
+
+        vbox = gtk_vbox_new(TRUE, 0);
+        gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, FALSE, 0);
+        gtk_widget_show(vbox);
+
+        /* Create all container button */
+        check = gtk_check_button_new_with_label(ALL_CONTS_STR);
+        gtk_box_pack_start(GTK_BOX(vbox), check, TRUE, TRUE, 0);
+        cont_helper->buttons[cont_count] = check;
+        if (select_count == cont_count)
+                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE);
+        gtk_widget_show(check);
+        g_signal_connect_swapped (check, "toggled",
+                                  G_CALLBACK (cont_toggle),
+                                  (gpointer) cont_helper);
+
+        /* Create per-container buttons */
+        cont_num = 0;
+        for (i = 0; i < CONT_HASH_SIZE; i++) {
+                for (cont = ginfo->rtg_info.containers[i]; cont; cont = cont->next) {
+                        g_snprintf(label, 200, "%s-%d", cont->name, cont->cid);
+                        check = gtk_check_button_new_with_label(label);
+                        cont_helper->buttons[cont_num] = check;
+                        cont_helper->conts[cont_num] = cont->cid;
+                        cont_helper->selected[cont_num] = cont->plotted;
+
+                        cont_num++;
+                }
+        }
+
+        for (start = 0; start < cont_count - 1; start++) {
+                min_cont = start;
+                for (i = start + 1; i < cont_count; i++) {
+                        if (cont_helper->conts[i] < cont_helper->conts[min_cont])
+                                min_cont = i;
+                }
+                if (min_cont != start) {
+                        twidget = cont_helper->buttons[min_cont];
+                        tint = cont_helper->conts[min_cont];
+                        tbool = cont_helper->selected[min_cont];
+
+                        cont_helper->buttons[min_cont] = cont_helper->buttons[start];
+                        cont_helper->conts[min_cont] = cont_helper->conts[start];
+                        cont_helper->selected[min_cont] = cont_helper->selected[start];
+                        cont_helper->buttons[start] = twidget;
+                        cont_helper->conts[start] = tint;
+                        cont_helper->selected[start] = tbool;
+                }
+        }
+        for (i = 0; i < cont_count; i++) {
+                check = cont_helper->buttons[i];
+                gtk_box_pack_start(GTK_BOX(vbox), check, TRUE, FALSE, 0);
+                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), cont_helper->selected[i]);
+                gtk_widget_show(check);
+                g_signal_connect_swapped (check, "toggled",
+                                          G_CALLBACK (cont_toggle),
+                                          (gpointer) cont_helper);
+
+        }
+
+
+        /* Size */
+        gtk_widget_size_request(hbox, &req);
+        height = req.height;
+        gtk_widget_size_request(scrollwin, &req);
+        height += req.height;
+        gtk_widget_size_request(dialog, &req);
+        width = req.width;
+        height += req.height;
+        if (width > DIALOG_WIDTH)
+                width = DIALOG_WIDTH;
+        if (height > DIALOG_HEIGHT)
+                height = DIALOG_HEIGHT;
+        gtk_widget_set_size_request(GTK_WIDGET(dialog),
+                                    width, height);
+        gtk_widget_show_all(dialog);
+
+        /* Run dialog */
+        result = gtk_dialog_run(GTK_DIALOG(dialog));
+        if  (result == GTK_RESPONSE_ACCEPT)
+                do_container_filter(ginfo, cont_helper, data);
+
+        gtk_widget_destroy(dialog);
+        g_free(cont_helper->conts);
+        g_free(cont_helper->buttons);
+        g_free(cont_helper->selected);
+        g_free(cont_helper);
+}
diff --git a/rt-plot-container.h b/rt-plot-container.h
new file mode 100644
index 0000000..e6c57b0
--- /dev/null
+++ b/rt-plot-container.h
@@ -0,0 +1,21 @@
+#ifndef __RT_PLOT_CONTAINER_H
+#define __RT_PLOT_CONTAINER_H
+
+#include "rt-plot-vcpu.h"
+
+typedef void (*cont_dialog_cb_func)(gboolean, gint*, gint*, gpointer);
+
+void trace_container_dialog(struct graph_info *ginfo,
+                            gpointer data);
+void rt_plot_container(struct graph_info *ginfo, int cid);
+int rt_plot_get_containers(struct graph_info *ginfo, gint **plotted,
+                            gboolean plotted_only);
+void rt_plot_add_all_containers(struct graph_info *ginfo);
+
+int get_server_info(struct graph_info *ginfo,
+                    struct rt_plot_common *rt,
+                    int match_sid, unsigned long long time,
+                    unsigned long long *release, unsigned long long *deadline,
+                    int *job, int *tid, struct record **record);
+
+#endif
diff --git a/rt-plot-task.c b/rt-plot-task.c
index 3175f23..c72013f 100644
--- a/rt-plot-task.c
+++ b/rt-plot-task.c
@@ -3,7 +3,7 @@
 #include "trace-graph.h"
 #include "trace-filter.h"
 
-#define DEBUG_LEVEL 4
+#define DEBUG_LEVEL 0
 #if DEBUG_LEVEL > 0
 #define dprintf(l, x...)                        \
         do {                                    \
diff --git a/rt-plot-vcpu-task.h b/rt-plot-vcpu-task.h
new file mode 100644
index 0000000..7edd4aa
--- /dev/null
+++ b/rt-plot-vcpu-task.h
@@ -0,0 +1,9 @@
+struct vcpu_info {
+        int                     sid;
+        int                     run_tid;
+        unsigned long long      run_time;
+        gboolean                fresh;
+        char                    *label;
+
+        struct cont_list        *cont;
+};
diff --git a/rt-plot-vcpu.c b/rt-plot-vcpu.c
new file mode 100644
index 0000000..fb1cf8d
--- /dev/null
+++ b/rt-plot-vcpu.c
@@ -0,0 +1,372 @@
+#include <stdio.h>
+#include <string.h>
+#include "trace-graph.h"
+
+#define DEBUG_LEVEL 0
+#if DEBUG_LEVEL > 0
+#define dprintf(l, x...)                        \
+        do {                                    \
+                if (l <= DEBUG_LEVEL)           \
+                        printf(x);              \
+        } while (0)
+#else
+#define dprintf(l, x...)        do { if (0) printf(x); } while (0)
+#endif
+
+static void update_tid(struct vcpu_info *info, int tid)
+{
+        info->fresh = FALSE;
+        if (tid != info->run_tid) {
+                info->run_tid = tid;
+                snprintf(info->label, LLABEL, "%d", tid);
+        }
+}
+
+
+static int try_release(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                       struct record *record, struct plot_info *info)
+{
+        int sid, job, match, ret = 0;
+        unsigned long long release, deadline;
+
+        match = rt_graph_check_server_release(ginfo, record, &sid, &job,
+                                              &release, &deadline);
+        if (match && sid == vcpu_info->sid) {
+                info->release = TRUE;
+                info->rtime = release;
+
+                info->deadline = TRUE;
+                info->dtime = deadline;
+
+                dprintf(3, "VCPU release for %d:%d on %d, rel: %llu, dead: %llu\n",
+                        sid, job, record->cpu, release, deadline);
+
+                ret = 1;
+        }
+        return ret;
+}
+
+static int try_completion(struct graph_info *ginfo,
+                          struct vcpu_info *vcpu_info,
+                          struct record *record, struct plot_info *info)
+{
+        int sid, job, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_server_completion(ginfo, record, &sid, &job, &ts);
+        if (match && sid == vcpu_info->sid) {
+
+                info->completion = TRUE;
+                info->ctime = ts;
+
+                dprintf(3, "VCPU completion for %d:%d on %d at %llu\n",
+                        sid, job, record->cpu, ts);
+                ret = 1;
+        }
+        return ret;
+}
+
+static int try_block(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                     struct record *record, struct plot_info *info)
+{
+        int sid, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_server_block(ginfo, record, &sid, &ts);
+        if (match && sid == vcpu_info->sid) {
+                vcpu_info->fresh = FALSE;
+                vcpu_info->block_time = ts;
+                vcpu_info->block_cpu = NO_CPU;
+                dprintf(3, "VCPU resume for %d on %d at %llu\n",
+                        sid, record->cpu, ts);
+                ret = 1;
+        }
+        return ret;
+}
+
+static int try_resume(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                      struct record *record, struct plot_info *info)
+{
+        int sid, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_server_resume(ginfo, record, &sid, &ts);
+
+        if (match && sid == vcpu_info->sid) {
+                info->box = TRUE;
+                info->bcolor = 0x0;
+                info->bfill = TRUE;
+                info->bthin = TRUE;
+                info->bstart = vcpu_info->block_time;
+                info->bend = ts;
+                vcpu_info->fresh = FALSE;
+
+                vcpu_info->block_time = 0ULL;
+                vcpu_info->block_cpu = NO_CPU;
+                dprintf(3, "VCPU resume for %d on %d at %llu\n",
+                        sid, record->cpu, ts);
+
+                ret = 1;
+        }
+        return ret;
+}
+
+static int
+try_server_switch_away(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                struct record *record, struct plot_info *info)
+{
+        int job, sid, tid, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_server_switch_away(ginfo, record,
+                                                  &sid, &job,
+                                                  &tid, &ts);
+        if (match && sid == vcpu_info->sid) {
+                update_tid(vcpu_info, tid);
+
+                if (vcpu_info->run_time && vcpu_info->run_time < ts &&
+                    job != 1) {
+                        info->box = TRUE;
+                        info->bcolor = hash_pid(tid);
+                        info->bfill = vcpu_info->running;
+                        info->bstart = vcpu_info->run_time;
+                        info->bend = ts;
+                        info->blabel = vcpu_info->label;
+                }
+
+                dprintf(3, "VCPU switch away from %d on %d:%d at %llu\n",
+                        tid, sid, job, ts);
+                vcpu_info->run_time = 0ULL;
+                vcpu_info->run_cpu = NO_CPU;
+                vcpu_info->run_tid = 0;
+                vcpu_info->running = FALSE;
+
+                ret = 1;
+        }
+
+        return ret;
+}
+
+static int try_server_switch_to(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                                struct record *record, struct plot_info *info)
+{
+        int job, sid, tid,  match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_server_switch_to(ginfo, record,
+                                                &sid, &job, &tid, &ts);
+        if (match && sid == vcpu_info->sid) {
+                update_tid(vcpu_info, tid);
+                vcpu_info->run_time = ts;
+                vcpu_info->run_cpu = record->cpu;
+                vcpu_info->run_tid = tid;
+                dprintf(3, "Switch to %d for %d:%d at %llu\n",
+                        tid, sid, job, ts);
+                ret = 1;
+        }
+        return ret;
+}
+
+static int try_switch_to(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                         struct record *record, struct plot_info *info)
+{
+        int job, pid, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_switch_to(ginfo, record, &pid, &job, &ts);
+        if (match && pid && pid == vcpu_info->run_tid && vcpu_info->run_time) {
+                vcpu_info->running = TRUE;
+
+                /* Draw empty box for time spent not running a task */
+                info->box = TRUE;
+                info->bcolor = hash_pid(pid);
+                info->bfill = FALSE;
+                info->bstart = vcpu_info->run_time;
+                info->bend = ts;
+                info->blabel = vcpu_info->label;
+
+                vcpu_info->run_time = ts;
+                ret = 1;
+        }
+        return ret;
+}
+
+static int try_switch_away(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                           struct record *record, struct plot_info *info)
+{
+        int job, pid, match, ret = 0;
+        unsigned long long ts;
+
+        match = rt_graph_check_switch_away(ginfo, record, &pid, &job, &ts);
+        if (match && pid && pid == vcpu_info->run_tid && vcpu_info->running) {
+                vcpu_info->running = FALSE;
+
+                info->box = TRUE;
+                info->bcolor = hash_pid(pid);
+                info->bfill = TRUE;
+                info->bstart = vcpu_info->run_time;
+                info->bend = ts;
+                info->blabel = vcpu_info->label;
+
+                vcpu_info->run_time = ts;
+                ret = 1;
+        }
+        return ret;
+}
+
+
+static void do_plot_end(struct graph_info *ginfo, struct vcpu_info *vcpu_info,
+                        struct plot_info *info)
+{
+        /* TODO: me */
+}
+
+
+static int rt_vcpu_plot_event(struct graph_info *ginfo, struct graph_plot *plot,
+                             struct record *record, struct plot_info *info)
+{
+        int match;
+        struct vcpu_info *vcpu_info = plot->private;
+
+        if (!record) {
+                do_plot_end(ginfo, vcpu_info, info);
+                return 0;
+        }
+
+        match = try_server_switch_away(ginfo, vcpu_info, record, info) ||
+                try_server_switch_to(ginfo, vcpu_info, record, info) ||
+                try_block(ginfo, vcpu_info, record, info) ||
+                try_resume(ginfo, vcpu_info, record, info) ||
+                try_release(ginfo, vcpu_info, record, info) ||
+                try_completion(ginfo, vcpu_info, record, info) ||
+                try_switch_to(ginfo, vcpu_info, record, info) ||
+                try_switch_away(ginfo, vcpu_info, record, info);
+        return match;
+}
+
+static void rt_vcpu_plot_start(struct graph_info *ginfo, struct graph_plot *plot,
+                               unsigned long long time)
+{
+        struct vcpu_info *vcpu_info = plot->private;
+
+        dprintf(4,"%s\n", __FUNCTION__);
+
+        vcpu_info->run_time = time;
+        vcpu_info->block_time = time;
+        vcpu_info->run_cpu = NO_CPU;
+        vcpu_info->run_tid = 0;
+        vcpu_info->block_cpu = NO_CPU;
+        vcpu_info->fresh = FALSE;
+
+        vcpu_info->fresh = TRUE;
+        vcpu_info->running = FALSE;
+
+        vcpu_info->run_tid = -1;
+        update_tid(vcpu_info, 0);
+}
+
+static void rt_vcpu_plot_destroy(struct graph_info *ginfo, struct graph_plot *plot)
+{
+        struct vcpu_info *vcpu_info = plot->private;
+        trace_graph_plot_remove_all_recs(ginfo, plot);
+        free(vcpu_info->label);
+        free(vcpu_info);
+}
+
+/*
+ * Return 1 if @record is relevant to @match_sid.
+ */
+static int rt_vcpu_plot_record_matches(struct rt_plot_common *rt,
+                                       struct graph_info *ginfo,
+                                       struct record *record)
+{
+        struct vcpu_info *vcpu_info = (struct vcpu_info*)rt;
+        int dint, sid, match;
+        unsigned long long dull;
+
+#define ARG ginfo, record, &sid
+        match = rt_graph_check_server_switch_to(ARG, &dint, &dint, &dull)   ||
+                rt_graph_check_server_switch_away(ARG, &dint, &dint, &dull) ||
+                rt_graph_check_server_completion(ARG, &dint, &dull)  ||
+                rt_graph_check_server_release(ARG, &dint, &dull, &dull)     ||
+                rt_graph_check_server_block(ARG, &dull)                     ||
+                rt_graph_check_server_resume(ARG, &dull);
+#undef ARG
+        return (sid == vcpu_info->sid);
+}
+
+/*
+ * Return true if the given record type is drawn on screen. This does not
+ * include event line markes.
+ */
+static int
+rt_vcpu_plot_is_drawn(struct graph_info *ginfo, int eid)
+{
+        struct rt_graph_info *rtg_info = &ginfo->rtg_info;
+        return (eid == rtg_info->server_switch_to_id   ||
+                eid == rtg_info->server_switch_away_id ||
+                eid == rtg_info->server_release_id     ||
+                eid == rtg_info->server_completion_id  ||
+                eid == rtg_info->server_block_id       ||
+                eid == rtg_info->server_resume_id);
+}
+
+static struct record*
+rt_vcpu_plot_write_header(struct rt_plot_common *rt,
+                          struct graph_info *ginfo,
+                          struct trace_seq *s,
+                          unsigned long long time)
+{
+        int is_running, job, tid;
+        unsigned long long release, deadline;
+        struct vcpu_info *vcpu_info = (struct vcpu_info*)rt;
+        struct record *record;
+
+        is_running = get_server_info(ginfo, rt, vcpu_info->sid, time,
+                                   &release, &deadline,
+                                   &job, &tid, &record);
+
+        trace_seq_printf(s, "%s-%d:%d", vcpu_info->cont->name,
+                         vcpu_info->sid, job);
+        if (is_running) {
+                trace_seq_printf(s, " - %d", tid);
+        }
+        trace_seq_putc(s, '\n');
+        return record;
+}
+
+
+const struct plot_callbacks rt_vcpu_cb = {
+        .start                  = rt_vcpu_plot_start,
+        .destroy                = rt_vcpu_plot_destroy,
+        .plot_event             = rt_vcpu_plot_event,
+        .display_last_event     = rt_plot_display_last_event,
+        .display_info           = rt_plot_display_info,
+        .match_time             = rt_plot_match_time,
+        .find_record            = rt_plot_find_record,
+};
+
+void insert_vcpu(struct graph_info *ginfo, struct cont_list *cont,
+                 struct vcpu_list *vcpu_info)
+{
+        struct graph_plot *plot;
+        struct vcpu_info  *vcpu;
+        char *label;
+
+        vcpu = malloc_or_die(sizeof(*vcpu));
+        vcpu->sid = vcpu_info->sid;
+        vcpu->cont = cont;
+        vcpu->label = malloc_or_die(LLABEL);
+
+        vcpu->common.record_matches = rt_vcpu_plot_record_matches;
+        vcpu->common.is_drawn = rt_vcpu_plot_is_drawn;
+        vcpu->common.write_header = rt_vcpu_plot_write_header;
+
+        g_assert(cont);
+
+        label = malloc_or_die(1);
+        snprintf(label, 2, " ");
+        plot = trace_graph_plot_append(ginfo, label, PLOT_TYPE_SERVER_CPU,
+                                       TIME_TYPE_RT, &rt_vcpu_cb, vcpu);
+        trace_graph_plot_add_all_recs(ginfo, plot);
+}
diff --git a/rt-plot-vcpu.h b/rt-plot-vcpu.h
new file mode 100644
index 0000000..14add34
--- /dev/null
+++ b/rt-plot-vcpu.h
@@ -0,0 +1,22 @@
+#include "trace-graph.h"
+
+struct vcpu_list;
+
+struct vcpu_info {
+        struct rt_plot_common   common;
+
+        int                     sid;
+        int                     run_tid;
+        int                     run_cpu;
+        unsigned long long      run_time;
+        int                     block_cpu;
+        unsigned long long      block_time;
+        gboolean                fresh;
+        gboolean                running;
+        char                    *label;
+
+        struct cont_list        *cont;
+};
+
+void insert_vcpu(struct graph_info *ginfo, struct cont_list *cont,
+                 struct vcpu_list *vcpu_info);
diff --git a/rt-plot.h b/rt-plot.h
new file mode 100644
index 0000000..0abc5c4
--- /dev/null
+++ b/rt-plot.h
@@ -0,0 +1,65 @@
+#ifndef __RT_PLOT_H
+#define __RT_PLOT_H
+
+#include <gtk/gtk.h>
+#include "trace-cmd.h"
+
+struct graph_plot;
+struct graph_info;
+struct rt_plot_common;
+
+typedef int (*record_matches_cb)(struct rt_plot_common *rt,
+                                 struct graph_info *ginfo,
+                                 struct record *record);
+typedef int (*is_drawn_cb)(struct graph_info *ginfo, int eid);
+typedef struct record* (*write_header_cb)(struct rt_plot_common *rt,
+                                          struct graph_info *ginfo,
+                                          struct trace_seq *s,
+                                          unsigned long long time);
+struct rt_plot_common {
+        record_matches_cb       record_matches;
+        is_drawn_cb             is_drawn;
+        write_header_cb         write_header;
+};
+
+int
+rt_plot_display_last_event(struct graph_info *ginfo, struct graph_plot *plot,
+                           struct trace_seq *s, unsigned long long time);
+int
+rt_plot_display_info(struct graph_info *ginfo, struct graph_plot *plot,
+                     struct trace_seq *s, unsigned long long time);
+struct record*
+rt_plot_find_record(struct graph_info *ginfo, struct graph_plot *plot,
+                    unsigned long long time);
+int
+rt_plot_match_time(struct graph_info *ginfo, struct graph_plot *plot,
+                   unsigned long long time);
+struct record*
+__find_rt_record(struct graph_info *ginfo, struct rt_plot_common *rt,
+                 guint64 time, int display);
+
+static inline struct record*
+find_rt_record(struct graph_info *ginfo, struct rt_plot_common *rt, guint64 time)
+{
+        return __find_rt_record(ginfo, rt, time, 0);
+}
+
+static inline struct record*
+find_rt_display_record(struct graph_info *ginfo,
+                       struct rt_plot_common *rt, guint64 time)
+{
+        return __find_rt_record(ginfo, rt, time, 1);
+}
+
+unsigned long long next_rts(struct graph_info *ginfo, int cpu,
+                            unsigned long long ft_target);
+void set_cpu_to_rts(struct graph_info *ginfo,
+                    unsigned long long rt_target, int cpu);
+void set_cpus_to_rts(struct graph_info *ginfo,
+                     unsigned long long rt_target);
+struct record* get_previous_release(struct graph_info *ginfo, int tid,
+                                    unsigned long long time, int *job,
+                                    unsigned long long *release,
+                                    unsigned long long *deadline);
+
+#endif
diff --git a/trace-graph.c b/trace-graph.c
index d309bc8..d8367ae 100644
--- a/trace-graph.c
+++ b/trace-graph.c
@@ -1695,7 +1695,7 @@ static void draw_plot_box(struct graph_info *ginfo, int i,
                            fill,
                            x1, y,
                            x2 - x1, size);
-        if (!thin && is_high_res(ginfo)) {
+        if (!thin && fill && is_high_res(ginfo)) {
                 gdk_draw_rectangle(ginfo->curr_pixmap,
                                    ginfo->draw->style->black_gc,
                                    FALSE,