+static void setup_iops_graph(struct gui *ui)
+{
+ if (ui->iops_graph)
+ graph_free(ui->iops_graph);
+ ui->iops_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
+ DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(ui->iops_graph, "IOPS");
+ graph_x_title(ui->iops_graph, "Time");
+ graph_y_title(ui->iops_graph, "IOPS");
+ graph_add_label(ui->iops_graph, "Read IOPS");
+ graph_add_label(ui->iops_graph, "Write IOPS");
+ graph_set_color(ui->iops_graph, "Read IOPS", 0.7, 0.0, 0.0);
+ graph_set_color(ui->iops_graph, "Write IOPS", 0.0, 0.0, 0.7);
+}
+
+static void setup_bandwidth_graph(struct gui *ui)
+{
+ if (ui->bandwidth_graph)
+ graph_free(ui->bandwidth_graph);
+ ui->bandwidth_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
+ DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(ui->bandwidth_graph, "Bandwidth");
+ graph_x_title(ui->bandwidth_graph, "Time");
+ graph_y_title(ui->bandwidth_graph, "Bandwidth");
+ graph_add_label(ui->bandwidth_graph, "Read Bandwidth");
+ graph_add_label(ui->bandwidth_graph, "Write Bandwidth");
+ graph_set_color(ui->bandwidth_graph, "Read Bandwidth", 0.7, 0.0, 0.0);
+ graph_set_color(ui->bandwidth_graph, "Write Bandwidth", 0.0, 0.0, 0.7);
+}
+
+static void clear_ui_info(struct gui *ui)
+{
+ gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
+ gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
+ gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
+ gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
+}
+
+static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *entry, *frame;
+
+ frame = gtk_frame_new(label);
+ entry = gtk_entry_new();
+ gtk_entry_set_editable(GTK_ENTRY(entry), 0);
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), entry);
+
+ return entry;
+}
+
+static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *label_widget;
+ GtkWidget *frame;
+
+ frame = gtk_frame_new(label);
+ label_widget = gtk_label_new(NULL);
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), label_widget);
+
+ return label_widget;
+}
+
+static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
+{
+ GtkWidget *button, *box;
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(hbox), box);
+
+ button = gtk_spin_button_new_with_range(min, max, 1.0);
+ gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
+
+ gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
+
+ return button;
+}
+
+static void gfio_set_connected(struct gui *ui, int connected)
+{
+ if (connected) {
+ gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
+ ui->connected = 1;
+ gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
+ gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
+ } else {
+ ui->connected = 0;
+ gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
+ gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
+ gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
+ }
+}
+
+static void label_set_int_value(GtkWidget *entry, unsigned int val)
+{
+ char tmp[80];
+
+ sprintf(tmp, "%u", val);
+ gtk_label_set_text(GTK_LABEL(entry), tmp);
+}
+
+static void entry_set_int_value(GtkWidget *entry, unsigned int val)
+{
+ char tmp[80];
+
+ sprintf(tmp, "%u", val);
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+}
+
+#define ALIGN_LEFT 1
+#define ALIGN_RIGHT 2
+#define INVISIBLE 4
+#define UNSORTABLE 8
+
+GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
+{
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *col;
+ double xalign = 0.0; /* left as default */
+ PangoAlignment align;
+ gboolean visible;
+
+ align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
+ (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
+ PANGO_ALIGN_CENTER;
+ visible = !(flags & INVISIBLE);
+
+ renderer = gtk_cell_renderer_text_new();
+ col = gtk_tree_view_column_new();
+
+ gtk_tree_view_column_set_title(col, title);
+ if (!(flags & UNSORTABLE))
+ gtk_tree_view_column_set_sort_column_id(col, index);
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_pack_start(col, renderer, TRUE);
+ gtk_tree_view_column_add_attribute(col, renderer, "text", index);
+ gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
+ switch (align) {
+ case PANGO_ALIGN_LEFT:
+ xalign = 0.0;
+ break;
+ case PANGO_ALIGN_CENTER:
+ xalign = 0.5;
+ break;
+ case PANGO_ALIGN_RIGHT:
+ xalign = 1.0;
+ break;
+ }
+ gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
+ gtk_tree_view_column_set_visible(col, visible);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
+ return col;
+}
+
+static void gfio_ui_setup_log(struct gui *ui)
+{
+ GtkTreeSelection *selection;
+ GtkListStore *model;
+ GtkWidget *tree_view;
+
+ model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
+
+ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ gtk_widget_set_can_focus(tree_view, FALSE);
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
+ g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
+ "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
+
+ tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
+ tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
+ tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
+ tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
+
+ ui->log_model = model;
+ ui->log_tree = tree_view;
+}
+
+static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
+ fio_fp64_t *plist,
+ unsigned int len,
+ const char *base,
+ unsigned int scale)
+{
+ GType types[FIO_IO_U_LIST_MAX_LEN];
+ GtkWidget *tree_view;
+ GtkTreeSelection *selection;
+ GtkListStore *model;
+ GtkTreeIter iter;
+ int i;
+
+ for (i = 0; i < len; i++)
+ types[i] = G_TYPE_INT;
+
+ model = gtk_list_store_newv(len, types);
+
+ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ gtk_widget_set_can_focus(tree_view, FALSE);
+
+ g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
+ "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
+
+ for (i = 0; i < len; i++) {
+ char fbuf[8];
+
+ sprintf(fbuf, "%2.2f%%", plist[i].u.f);
+ tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
+ }
+
+ gtk_list_store_append(model, &iter);
+
+ for (i = 0; i < len; i++) {
+ if (scale)
+ ovals[i] = (ovals[i] + 999) / 1000;
+ gtk_list_store_set(model, &iter, i, ovals[i], -1);
+ }
+
+ return tree_view;
+}
+
+static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
+ int ddir)
+{
+ unsigned int *io_u_plat = ts->io_u_plat[ddir];
+ unsigned long nr = ts->clat_stat[ddir].samples;
+ fio_fp64_t *plist = ts->percentile_list;
+ unsigned int *ovals, len, minv, maxv, scale_down;
+ const char *base;
+ GtkWidget *tree_view, *frame, *hbox;
+ char tmp[64];
+
+ len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
+ if (!len)
+ goto out;
+
+ /*
+ * We default to usecs, but if the value range is such that we
+ * should scale down to msecs, do that.
+ */
+ if (minv > 2000 && maxv > 99999) {
+ scale_down = 1;
+ base = "msec";
+ } else {
+ scale_down = 0;
+ base = "usec";
+ }
+
+ tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
+
+ sprintf(tmp, "Completion percentiles (%s)", base);
+ frame = gtk_frame_new(tmp);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), hbox);
+
+ gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
+out:
+ if (ovals)
+ free(ovals);
+}
+
+static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
+ unsigned long max, double mean, double dev)
+{
+ const char *base = "(usec)";
+ GtkWidget *hbox, *label, *frame;
+ char *minp, *maxp;
+ char tmp[64];
+
+ if (!usec_to_msec(&min, &max, &mean, &dev))
+ base = "(msec)";
+
+ minp = num2str(min, 6, 1, 0);
+ maxp = num2str(max, 6, 1, 0);
+
+ sprintf(tmp, "%s %s", name, base);
+ frame = gtk_frame_new(tmp);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), hbox);
+
+ label = new_info_label_in_frame(hbox, "Minimum");
+ gtk_label_set_text(GTK_LABEL(label), minp);
+ label = new_info_label_in_frame(hbox, "Maximum");
+ gtk_label_set_text(GTK_LABEL(label), maxp);
+ label = new_info_label_in_frame(hbox, "Average");
+ sprintf(tmp, "%5.02f", mean);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+ label = new_info_label_in_frame(hbox, "Standard deviation");
+ sprintf(tmp, "%5.02f", dev);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+
+ free(minp);
+ free(maxp);
+
+}
+
+#define GFIO_CLAT 1
+#define GFIO_SLAT 2
+#define GFIO_LAT 4
+
+static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
+ struct thread_stat *ts, int ddir)
+{
+ const char *ddir_label[2] = { "Read", "Write" };
+ GtkWidget *frame, *label, *box, *vbox, *main_vbox;
+ unsigned long min[3], max[3], runt;
+ unsigned long long bw, iops;
+ unsigned int flags = 0;
+ double mean[3], dev[3];
+ char *io_p, *bw_p, *iops_p;
+ int i2p;
+
+ if (!ts->runtime[ddir])
+ return;
+
+ i2p = is_power_of_2(rs->kb_base);
+ runt = ts->runtime[ddir];
+
+ bw = (1000 * ts->io_bytes[ddir]) / runt;
+ io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
+ bw_p = num2str(bw, 6, 1, i2p);
+
+ iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
+ iops_p = num2str(iops, 6, 1, 0);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
+
+ frame = gtk_frame_new(ddir_label[ddir]);
+ gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
+
+ main_vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), main_vbox);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
+
+ label = new_info_label_in_frame(box, "IO");
+ gtk_label_set_text(GTK_LABEL(label), io_p);
+ label = new_info_label_in_frame(box, "Bandwidth");
+ gtk_label_set_text(GTK_LABEL(label), bw_p);
+ label = new_info_label_in_frame(box, "IOPS");
+ gtk_label_set_text(GTK_LABEL(label), iops_p);
+ label = new_info_label_in_frame(box, "Runtime (msec)");
+ label_set_int_value(label, ts->runtime[ddir]);
+
+ if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
+ double p_of_agg = 100.0;
+ const char *bw_str = "KB";
+ char tmp[32];
+
+ if (rs->agg[ddir]) {
+ p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
+ if (p_of_agg > 100.0)
+ p_of_agg = 100.0;
+ }
+
+ if (mean[0] > 999999.9) {
+ min[0] /= 1000.0;
+ max[0] /= 1000.0;
+ mean[0] /= 1000.0;
+ dev[0] /= 1000.0;
+ bw_str = "MB";
+ }
+
+ sprintf(tmp, "Bandwidth (%s)", bw_str);
+ frame = gtk_frame_new(tmp);
+ gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+
+ label = new_info_label_in_frame(box, "Minimum");
+ label_set_int_value(label, min[0]);
+ label = new_info_label_in_frame(box, "Maximum");
+ label_set_int_value(label, max[0]);
+ label = new_info_label_in_frame(box, "Percentage of jobs");
+ sprintf(tmp, "%3.2f%%", p_of_agg);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+ label = new_info_label_in_frame(box, "Average");
+ sprintf(tmp, "%5.02f", mean[0]);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+ label = new_info_label_in_frame(box, "Standard deviation");
+ sprintf(tmp, "%5.02f", dev[0]);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+ }
+
+ if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
+ flags |= GFIO_SLAT;
+ if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
+ flags |= GFIO_CLAT;
+ if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
+ flags |= GFIO_LAT;
+
+ if (flags) {
+ frame = gtk_frame_new("Latency");
+ gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
+
+ vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+
+ if (flags & GFIO_SLAT)
+ gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
+ if (flags & GFIO_CLAT)
+ gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
+ if (flags & GFIO_LAT)
+ gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
+ }
+
+ if (ts->clat_percentiles)
+ gfio_show_clat_percentiles(main_vbox, ts, ddir);
+
+
+ free(io_p);
+ free(bw_p);
+ free(iops_p);
+}
+
+static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
+ const char **labels)
+{
+ GtkWidget *tree_view;
+ GtkTreeSelection *selection;
+ GtkListStore *model;
+ GtkTreeIter iter;
+ GType *types;
+ int i, skipped;
+
+ /*
+ * Check if all are empty, in which case don't bother
+ */
+ for (i = 0, skipped = 0; i < num; i++)
+ if (lat[i] <= 0.0)
+ skipped++;
+
+ if (skipped == num)
+ return NULL;
+
+ types = malloc(num * sizeof(GType));
+
+ for (i = 0; i < num; i++)
+ types[i] = G_TYPE_STRING;
+
+ model = gtk_list_store_newv(num, types);
+ free(types);
+ types = NULL;
+
+ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ gtk_widget_set_can_focus(tree_view, FALSE);
+
+ g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
+ "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
+
+ for (i = 0; i < num; i++)
+ tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
+
+ gtk_list_store_append(model, &iter);
+
+ for (i = 0; i < num; i++) {
+ char fbuf[32];
+
+ if (lat[i] <= 0.0)
+ sprintf(fbuf, "0.00");
+ else
+ sprintf(fbuf, "%3.2f%%", lat[i]);
+
+ gtk_list_store_set(model, &iter, i, fbuf, -1);
+ }
+
+ return tree_view;
+}
+
+static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
+{
+ GtkWidget *box, *frame, *tree_view;
+ double io_u_lat_u[FIO_IO_U_LAT_U_NR];
+ double io_u_lat_m[FIO_IO_U_LAT_M_NR];
+ const char *uranges[] = { "2", "4", "10", "20", "50", "100",
+ "250", "500", "750", "1000", };
+ const char *mranges[] = { "2", "4", "10", "20", "50", "100",
+ "250", "500", "750", "1000", "2000",
+ ">= 2000", };
+
+ stat_calc_lat_u(ts, io_u_lat_u);
+ stat_calc_lat_m(ts, io_u_lat_m);
+
+ tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
+ if (tree_view) {
+ frame = gtk_frame_new("Latency buckets (usec)");
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+ gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
+ }
+
+ tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
+ if (tree_view) {
+ frame = gtk_frame_new("Latency buckets (msec)");
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+ gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
+ }
+}
+
+static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
+{
+ GtkWidget *box, *frame, *entry;
+ double usr_cpu, sys_cpu;
+ unsigned long runtime;
+ char tmp[32];
+
+ runtime = ts->total_run_time;
+ if (runtime) {
+ double runt = (double) runtime;
+
+ usr_cpu = (double) ts->usr_time * 100 / runt;
+ sys_cpu = (double) ts->sys_time * 100 / runt;
+ } else {
+ usr_cpu = 0;
+ sys_cpu = 0;
+ }
+
+ frame = gtk_frame_new("OS resources");
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+
+ entry = new_info_entry_in_frame(box, "User CPU");
+ sprintf(tmp, "%3.2f%%", usr_cpu);
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+ entry = new_info_entry_in_frame(box, "System CPU");
+ sprintf(tmp, "%3.2f%%", sys_cpu);
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+ entry = new_info_entry_in_frame(box, "Context switches");
+ entry_set_int_value(entry, ts->ctx);
+ entry = new_info_entry_in_frame(box, "Major faults");
+ entry_set_int_value(entry, ts->majf);
+ entry = new_info_entry_in_frame(box, "Minor faults");
+ entry_set_int_value(entry, ts->minf);
+}
+static void gfio_add_sc_depths_tree(GtkListStore *model,
+ struct thread_stat *ts, unsigned int len,
+ int submit)
+{
+ double io_u_dist[FIO_IO_U_MAP_NR];
+ GtkTreeIter iter;
+ /* Bits 0, and 3-8 */
+ const int add_mask = 0x1f9;
+ int i, j;
+
+ if (submit)
+ stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
+ else
+ stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
+
+ gtk_list_store_append(model, &iter);
+
+ gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
+
+ for (i = 1, j = 0; i < len; i++) {
+ char fbuf[32];
+
+ if (!(add_mask & (1UL << (i - 1))))
+ sprintf(fbuf, "0.0%%");
+ else {
+ sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
+ j++;
+ }
+
+ gtk_list_store_set(model, &iter, i, fbuf, -1);
+ }
+
+}
+
+static void gfio_add_total_depths_tree(GtkListStore *model,
+ struct thread_stat *ts, unsigned int len)
+{
+ double io_u_dist[FIO_IO_U_MAP_NR];
+ GtkTreeIter iter;
+ /* Bits 1-6, and 8 */
+ const int add_mask = 0x17e;
+ int i, j;
+
+ stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
+
+ gtk_list_store_append(model, &iter);
+
+ gtk_list_store_set(model, &iter, 0, "Total", -1);
+
+ for (i = 1, j = 0; i < len; i++) {
+ char fbuf[32];
+
+ if (!(add_mask & (1UL << (i - 1))))
+ sprintf(fbuf, "0.0%%");
+ else {
+ sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
+ j++;
+ }
+
+ gtk_list_store_set(model, &iter, i, fbuf, -1);
+ }
+
+}
+
+static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
+{
+ GtkWidget *frame, *box, *tree_view;
+ GtkTreeSelection *selection;
+ GtkListStore *model;
+ GType types[FIO_IO_U_MAP_NR + 1];
+ int i;
+#define NR_LABELS 10
+ const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
+
+ frame = gtk_frame_new("IO depths");
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+
+ for (i = 0; i < NR_LABELS; i++)
+ types[i] = G_TYPE_STRING;
+
+ model = gtk_list_store_newv(NR_LABELS, types);
+
+ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ gtk_widget_set_can_focus(tree_view, FALSE);
+
+ g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
+ "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
+
+ for (i = 0; i < NR_LABELS; i++)
+ tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
+
+ gfio_add_total_depths_tree(model, ts, NR_LABELS);
+ gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
+ gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
+
+ gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
+}
+
+static gboolean results_window_delete(GtkWidget *w, gpointer data)
+{
+ struct gui *ui = (struct gui *) data;
+
+ gtk_widget_destroy(w);
+ ui->results_window = NULL;
+ ui->results_notebook = NULL;
+ return TRUE;
+}
+
+static GtkWidget *get_results_window(struct gui *ui)
+{
+ GtkWidget *win, *notebook;
+
+ if (ui->results_window)
+ return ui->results_notebook;
+
+ win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(win), "Results");
+ g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ui);
+ g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ui);
+
+ notebook = gtk_notebook_new();
+ gtk_container_add(GTK_CONTAINER(win), notebook);
+
+ ui->results_window = win;
+ ui->results_notebook = notebook;
+ return ui->results_notebook;
+}
+
+static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
+ struct group_run_stats *rs)
+{
+ GtkWidget *res_win, *box, *vbox, *entry;
+ struct gfio_client *gc = client->client_data;
+
+ gdk_threads_enter();
+
+ res_win = get_results_window(gc->ui);
+
+ vbox = gtk_vbox_new(FALSE, 3);
+
+ box = gtk_hbox_new(TRUE, 3);
+ gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
+
+ gtk_notebook_append_page(GTK_NOTEBOOK(res_win), vbox, gtk_label_new(ts->name));
+
+ gc->results_widget = vbox;
+
+ entry = new_info_entry_in_frame(box, "Name");
+ gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
+ if (strlen(ts->description)) {
+ entry = new_info_entry_in_frame(box, "Description");
+ gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
+ }
+ entry = new_info_entry_in_frame(box, "Group ID");
+ entry_set_int_value(entry, ts->groupid);
+ entry = new_info_entry_in_frame(box, "Jobs");
+ entry_set_int_value(entry, ts->members);
+ entry = new_info_entry_in_frame(box, "Error");
+ entry_set_int_value(entry, ts->error);
+ entry = new_info_entry_in_frame(box, "PID");
+ entry_set_int_value(entry, ts->pid);
+
+ if (ts->io_bytes[DDIR_READ])
+ gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
+ if (ts->io_bytes[DDIR_WRITE])
+ gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
+
+ gfio_show_latency_buckets(vbox, ts);
+ gfio_show_cpu_usage(vbox, ts);
+ gfio_show_io_depths(vbox, ts);
+
+ gtk_widget_show_all(gc->ui->results_window);
+ gdk_threads_leave();
+}
+
+static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
+ struct gfio_client *gc = client->client_data;
+ GtkTreeIter iter;
+ struct tm *tm;
+ time_t sec;
+ char tmp[64], timebuf[80];
+
+ sec = p->log_sec;
+ tm = localtime(&sec);
+ strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
+ sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
+
+ gdk_threads_enter();
+
+ gtk_list_store_append(gc->ui->log_model, &iter);
+ gtk_list_store_set(gc->ui->log_model, &iter, 0, timebuf, -1);
+ gtk_list_store_set(gc->ui->log_model, &iter, 1, client->hostname, -1);
+ gtk_list_store_set(gc->ui->log_model, &iter, 2, p->level, -1);
+ gtk_list_store_set(gc->ui->log_model, &iter, 3, p->buf, -1);
+
+ gdk_threads_leave();
+}
+
+static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
+ struct gfio_client *gc = client->client_data;
+ GtkWidget *box, *frame, *entry, *vbox;
+
+ gdk_threads_enter();
+
+ if (!gc->results_widget) {
+ printf("no results!\n");
+ goto out;
+ }
+
+ if (!gc->disk_util_frame) {
+ gc->disk_util_frame = gtk_frame_new("Disk utilization");
+ gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
+ }
+
+ vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
+
+ frame = gtk_frame_new((char *) p->dus.name);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
+
+ box = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+
+ frame = gtk_frame_new("Read");
+ gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
+ vbox = gtk_hbox_new(TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+ entry = new_info_entry_in_frame(vbox, "IOs");
+ entry_set_int_value(entry, p->dus.ios[0]);
+ entry = new_info_entry_in_frame(vbox, "Merges");
+ entry_set_int_value(entry, p->dus.merges[0]);
+ entry = new_info_entry_in_frame(vbox, "Sectors");
+ entry_set_int_value(entry, p->dus.sectors[0]);
+ entry = new_info_entry_in_frame(vbox, "Ticks");
+ entry_set_int_value(entry, p->dus.ticks[0]);
+
+ frame = gtk_frame_new("Write");
+ gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
+ vbox = gtk_hbox_new(TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+ entry = new_info_entry_in_frame(vbox, "IOs");
+ entry_set_int_value(entry, p->dus.ios[1]);
+ entry = new_info_entry_in_frame(vbox, "Merges");
+ entry_set_int_value(entry, p->dus.merges[1]);
+ entry = new_info_entry_in_frame(vbox, "Sectors");
+ entry_set_int_value(entry, p->dus.sectors[1]);
+ entry = new_info_entry_in_frame(vbox, "Ticks");
+ entry_set_int_value(entry, p->dus.ticks[1]);
+
+ frame = gtk_frame_new("Shared");
+ gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
+ vbox = gtk_hbox_new(TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+ entry = new_info_entry_in_frame(vbox, "IO ticks");
+ entry_set_int_value(entry, p->dus.io_ticks);
+ entry = new_info_entry_in_frame(vbox, "Time in queue");
+ entry_set_int_value(entry, p->dus.time_in_queue);
+
+ gtk_widget_show_all(gc->results_widget);
+out:
+ gdk_threads_leave();
+}
+
+extern int sum_stat_clients;
+extern struct thread_stat client_ts;
+extern struct group_run_stats client_gs;
+
+static int sum_stat_nr;
+
+static void gfio_thread_status_op(struct fio_client *client,
+ struct fio_net_cmd *cmd)
+{
+ struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
+
+ gfio_display_ts(client, &p->ts, &p->rs);
+
+ if (sum_stat_clients == 1)
+ return;
+
+ sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
+ sum_group_stats(&client_gs, &p->rs);
+
+ client_ts.members++;
+ client_ts.groupid = p->ts.groupid;
+
+ if (++sum_stat_nr == sum_stat_clients) {
+ strcpy(client_ts.name, "All clients");
+ gfio_display_ts(client, &client_ts, &client_gs);
+ }
+}
+
+static void gfio_group_stats_op(struct fio_client *client,
+ struct fio_net_cmd *cmd)
+{
+ gdk_threads_enter();
+ printf("gfio_group_stats_op called\n");
+ fio_client_ops.group_stats(client, cmd);
+ gdk_threads_leave();
+}
+
+static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
+{
+ struct gui *ui = (struct gui *) p;
+ cairo_t *cr;
+
+ cr = gdk_cairo_create(w->window);
+
+ cairo_set_source_rgb(cr, 0, 0, 0);
+
+ cairo_save(cr);
+ cairo_translate(cr, 0, 0);
+ line_graph_draw(ui->bandwidth_graph, cr);
+ cairo_stroke(cr);
+ cairo_restore(cr);
+
+ cairo_save(cr);
+ cairo_translate(cr, DRAWING_AREA_XDIM / 2.0, 0);
+ // DRAWING_AREA_YDIM * 0.05);
+ line_graph_draw(ui->iops_graph, cr);
+ cairo_stroke(cr);
+ cairo_restore(cr);
+ cairo_destroy(cr);
+
+ return FALSE;
+}
+
+static void gfio_update_eta(struct jobs_eta *je)
+{
+ static int eta_good;
+ char eta_str[128];
+ char output[256];
+ char tmp[32];
+ double perc = 0.0;
+ int i2p = 0;
+
+ gdk_threads_enter();
+
+ eta_str[0] = '\0';
+ output[0] = '\0';
+
+ if (je->eta_sec != INT_MAX && je->elapsed_sec) {
+ perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
+ eta_to_str(eta_str, je->eta_sec);
+ }
+
+ sprintf(tmp, "%u", je->nr_running);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
+ sprintf(tmp, "%u", je->files_open);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
+
+#if 0
+ if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
+ if (je->m_rate || je->t_rate) {
+ char *tr, *mr;
+
+ mr = num2str(je->m_rate, 4, 0, i2p);
+ tr = num2str(je->t_rate, 4, 0, i2p);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta);
+ p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
+ free(tr);
+ free(mr);
+ } else if (je->m_iops || je->t_iops)
+ p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
+
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
+#endif
+
+ if (je->eta_sec != INT_MAX && je->nr_running) {
+ char *iops_str[2];
+ char *rate_str[2];
+
+ if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
+ strcpy(output, "-.-% done");
+ else {
+ eta_good = 1;
+ perc *= 100.0;
+ sprintf(output, "%3.1f%% done", perc);
+ }
+
+ rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
+ rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
+
+ iops_str[0] = num2str(je->iops[0], 4, 1, 0);
+ iops_str[1] = num2str(je->iops[1], 4, 1, 0);
+
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
+ gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
+
+ graph_add_xy_data(ui.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
+ graph_add_xy_data(ui.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
+ graph_add_xy_data(ui.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
+ graph_add_xy_data(ui.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
+
+ free(rate_str[0]);
+ free(rate_str[1]);
+ free(iops_str[0]);
+ free(iops_str[1]);
+ }