+typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
+
+static void connect_clicked(GtkWidget *widget, gpointer data);
+static void start_job_clicked(GtkWidget *widget, gpointer data);
+static void send_clicked(GtkWidget *widget, gpointer data);
+
+static struct button_spec {
+ const char *buttontext;
+ clickfunction f;
+ const char *tooltiptext;
+ const int start_insensitive;
+} buttonspeclist[] = {
+#define CONNECT_BUTTON 0
+#define SEND_BUTTON 1
+#define START_JOB_BUTTON 2
+ { "Connect", connect_clicked, "Connect to host", 0 },
+ { "Send", send_clicked, "Send job description to host", 1 },
+ { "Start Job", start_job_clicked,
+ "Start the current job on the server", 1 },
+};
+
+struct probe_widget {
+ GtkWidget *hostname;
+ GtkWidget *os;
+ GtkWidget *arch;
+ GtkWidget *fio_ver;
+};
+
+struct eta_widget {
+ GtkWidget *names;
+ GtkWidget *iotype;
+ GtkWidget *ioengine;
+ GtkWidget *iodepth;
+ GtkWidget *jobs;
+ GtkWidget *files;
+ GtkWidget *read_bw;
+ GtkWidget *read_iops;
+ GtkWidget *cr_bw;
+ GtkWidget *cr_iops;
+ GtkWidget *write_bw;
+ GtkWidget *write_iops;
+ GtkWidget *cw_bw;
+ GtkWidget *cw_iops;
+};
+
+struct gfio_graphs {
+#define DRAWING_AREA_XDIM 1000
+#define DRAWING_AREA_YDIM 400
+ GtkWidget *drawing_area;
+ int drawing_area_xdim;
+ int drawing_area_ydim;
+
+ struct graph *iops_graph;
+ struct graph *bandwidth_graph;
+};
+
+/*
+ * Main window widgets and data
+ */
+struct gui {
+ GtkWidget *window;
+ GtkWidget *vbox;
+ GtkWidget *topvbox;
+ GtkWidget *topalign;
+ GtkWidget *bottomalign;
+ GtkWidget *thread_status_pb;
+ GtkWidget *buttonbox;
+ GtkWidget *scrolled_window;
+ GtkWidget *notebook;
+ GtkWidget *error_info_bar;
+ GtkWidget *error_label;
+ GtkListStore *log_model;
+ GtkWidget *log_tree;
+ GtkWidget *log_view;
+ struct gfio_graphs graphs;
+ struct probe_widget probe;
+ struct eta_widget eta;
+ pthread_t server_t;
+
+ pthread_t t;
+ int handler_running;
+
+ struct flist_head list;
+} main_ui;
+
+/*
+ * Notebook entry
+ */
+struct gui_entry {
+ struct flist_head list;
+ struct gui *ui;
+
+ GtkWidget *vbox;
+ GtkWidget *topvbox;
+ GtkWidget *topalign;
+ GtkWidget *bottomalign;
+ GtkWidget *thread_status_pb;
+ GtkWidget *buttonbox;
+ GtkWidget *button[ARRAYSIZE(buttonspeclist)];
+ GtkWidget *scrolled_window;
+ GtkWidget *notebook;
+ GtkWidget *error_info_bar;
+ GtkWidget *error_label;
+ GtkWidget *results_notebook;
+ GtkWidget *results_window;
+ GtkListStore *log_model;
+ GtkWidget *log_tree;
+ GtkWidget *log_view;
+ struct gfio_graphs graphs;
+ struct probe_widget probe;
+ struct eta_widget eta;
+ GtkWidget *page_label;
+ gint page_num;
+ int connected;
+
+ struct gfio_client *client;
+ int nr_job_files;
+ char **job_files;
+};
+
+struct gfio_client {
+ struct gui_entry *ge;
+ struct fio_client *client;
+ GtkWidget *results_widget;
+ GtkWidget *disk_util_frame;
+ GtkWidget *err_entry;
+ unsigned int job_added;
+ struct thread_options o;
+};
+
+static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
+static void gfio_update_thread_status_all(char *status_message, double perc);
+void report_error(GError *error);
+
+static struct graph *setup_iops_graph(void)
+{
+ struct graph *g;
+
+ g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(g, "IOPS");
+ graph_x_title(g, "Time (secs)");
+ graph_y_title(g, "IOs / sec");
+ graph_add_label(g, "Read IOPS");
+ graph_add_label(g, "Write IOPS");
+ graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
+ graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
+ line_graph_set_data_count_limit(g, gfio_graph_limit);
+ return g;
+}
+
+static struct graph *setup_bandwidth_graph(void)
+{
+ struct graph *g;
+
+ g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(g, "Bandwidth");
+ graph_x_title(g, "Time (secs)");
+ graph_y_title(g, "Kbytes / sec");
+ graph_add_label(g, "Read Bandwidth");
+ graph_add_label(g, "Write Bandwidth");
+ graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
+ graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
+ line_graph_set_data_count_limit(g, 100);
+ return g;
+}
+
+static void setup_graphs(struct gfio_graphs *g)
+{
+ g->iops_graph = setup_iops_graph();
+ g->bandwidth_graph = setup_bandwidth_graph();
+}
+
+static void clear_ge_ui_info(struct gui_entry *ge)
+{
+ gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
+#if 0
+ /* should we empty it... */
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
+#endif
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.iotype), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.ioengine), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.iodepth), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
+}
+
+static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *entry, *frame;
+
+ frame = gtk_frame_new(label);
+ entry = gtk_combo_box_new_text();
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), entry);
+
+ return entry;
+}
+
+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_entry *ge, int connected)
+{
+ if (connected) {
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 1);
+ ge->connected = 1;
+ gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Disconnect");
+ gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 1);
+ } else {
+ ge->connected = 0;
+ gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Connect");
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->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_entry *ge = (struct gui_entry *) data;
+
+ gtk_widget_destroy(w);
+ ge->results_window = NULL;
+ ge->results_notebook = NULL;
+ return TRUE;
+}
+
+static GtkWidget *get_results_window(struct gui_entry *ge)
+{
+ GtkWidget *win, *notebook;
+
+ if (ge->results_window)
+ return ge->results_notebook;
+
+ win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(win), "Results");
+ gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768);
+ g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
+ g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
+
+ notebook = gtk_notebook_new();
+ gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
+ gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
+ gtk_container_add(GTK_CONTAINER(win), notebook);
+
+ ge->results_window = win;
+ ge->results_notebook = notebook;
+ return ge->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, *scroll;
+ struct gfio_client *gc = client->client_data;
+
+ gdk_threads_enter();
+
+ res_win = get_results_window(gc->ge);
+
+ scroll = gtk_scrolled_window_new(NULL, NULL);
+ gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+
+ vbox = gtk_vbox_new(FALSE, 3);
+
+ box = gtk_hbox_new(FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5);
+
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
+
+ gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, 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);
+ gc->err_entry = 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->ge->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 gui *ui = &main_ui;
+ 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(ui->log_model, &iter);
+ gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1);
+ gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1);
+ gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1);
+ gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1);
+
+ if (p->level == FIO_LOG_ERR)
+ view_log(NULL, (gpointer) ui);
+
+ 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;
+ double util;
+ char tmp[16];
+
+ gdk_threads_enter();
+
+ if (!gc->results_widget)
+ 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);
+
+ util = 0.0;
+ if (p->dus.msec)
+ util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec;
+ if (util > 100.0)
+ util = 100.0;
+
+ sprintf(tmp, "%3.2f%%", util);
+ entry = new_info_entry_in_frame(vbox, "Disk utilization");
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+
+ 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)
+{
+ /* We're ignoring group stats for now */
+}
+
+static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
+ gpointer data)
+{
+ struct gfio_graphs *g = data;
+
+ g->drawing_area_xdim = w->allocation.width;
+ g->drawing_area_ydim = w->allocation.height;
+ return TRUE;
+}
+
+static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
+{
+ struct gfio_graphs *g = p;
+ cairo_t *cr;
+
+ graph_set_size(g->iops_graph, g->drawing_area_xdim / 2.0,
+ g->drawing_area_ydim);
+ graph_set_size(g->bandwidth_graph, g->drawing_area_xdim / 2.0,
+ g->drawing_area_ydim);
+ 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(g->bandwidth_graph, cr);
+ cairo_stroke(cr);
+ cairo_restore(cr);
+
+ cairo_save(cr);
+ cairo_translate(cr, g->drawing_area_xdim / 2.0, 0);
+ line_graph_draw(g->iops_graph, cr);
+ cairo_stroke(cr);
+ cairo_restore(cr);
+ cairo_destroy(cr);
+
+ return FALSE;
+}
+
+/*
+ * Client specific ETA
+ */
+static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je)
+{
+ struct gfio_client *gc = client->client_data;
+ struct gui_entry *ge = gc->ge;
+ 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(ge->eta.jobs), tmp);
+ sprintf(tmp, "%u", je->files_open);
+ gtk_entry_set_text(GTK_ENTRY(ge->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(ge->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(ge->eta.cr_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->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(ge->eta.read_bw), rate_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]);
+
+ graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
+ graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
+ graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
+ graph_add_xy_data(ge->graphs.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]);
+ }
+
+ if (eta_str[0]) {
+ char *dst = output + strlen(output);
+
+ sprintf(dst, " - %s", eta_str);
+ }
+
+ gfio_update_thread_status(ge, output, perc);
+ gdk_threads_leave();
+}
+
+/*
+ * Update ETA in main window for all clients
+ */
+static void gfio_update_all_eta(struct jobs_eta *je)
+{
+ struct gui *ui = &main_ui;
+ static int eta_good;
+ char eta_str[128];
+ char output[256];
+ 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);
+ }
+
+#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
+
+ entry_set_int_value(ui->eta.jobs, je->nr_running);
+
+ 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->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
+ graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
+ graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
+ graph_add_xy_data(ui->graphs.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]);
+ }
+
+ if (eta_str[0]) {
+ char *dst = output + strlen(output);
+
+ sprintf(dst, " - %s", eta_str);
+ }
+
+ gfio_update_thread_status_all(output, perc);
+ gdk_threads_leave();
+}
+
+static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
+ struct gfio_client *gc = client->client_data;
+ struct gui_entry *ge = gc->ge;
+ const char *os, *arch;
+ char buf[64];
+
+ os = fio_get_os_string(probe->os);
+ if (!os)
+ os = "unknown";
+
+ arch = fio_get_arch_string(probe->arch);
+ if (!arch)
+ os = "unknown";
+
+ if (!client->name)
+ client->name = strdup((char *) probe->hostname);
+
+ gdk_threads_enter();
+
+ gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname);
+ gtk_label_set_text(GTK_LABEL(ge->probe.os), os);
+ gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch);
+ sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
+ gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf);
+
+ gfio_set_connected(ge, 1);
+
+ gdk_threads_leave();
+}
+
+static void gfio_update_thread_status(struct gui_entry *ge,
+ char *status_message, double perc)
+{
+ static char message[100];
+ const char *m = message;
+
+ strncpy(message, status_message, sizeof(message) - 1);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0);
+ gtk_widget_queue_draw(main_ui.window);
+}
+
+static void gfio_update_thread_status_all(char *status_message, double perc)
+{
+ struct gui *ui = &main_ui;
+ static char message[100];
+ const char *m = message;
+
+ strncpy(message, status_message, sizeof(message) - 1);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0);
+ gtk_widget_queue_draw(ui->window);
+}
+
+static void gfio_quit_op(struct fio_client *client)
+{
+ struct gfio_client *gc = client->client_data;
+
+ gdk_threads_enter();
+ gfio_set_connected(gc->ge, 0);
+ gdk_threads_leave();
+}
+
+static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
+ struct gfio_client *gc = client->client_data;
+ struct thread_options *o = &gc->o;
+ struct gui_entry *ge = gc->ge;
+ char tmp[8];
+
+ convert_thread_options_to_cpu(o, &p->top);
+
+ gdk_threads_enter();
+
+ gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name);
+
+ gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name);
+ gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0);
+
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.iotype), ddir_str(o->td_ddir));
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.ioengine), (gchar *) o->ioengine);
+
+ sprintf(tmp, "%u", o->iodepth);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.iodepth), tmp);
+
+ gc->job_added++;
+
+ gdk_threads_leave();
+}
+
+static void gfio_client_timed_out(struct fio_client *client)
+{
+ struct gfio_client *gc = client->client_data;
+ GtkWidget *dialog, *label, *content;
+ char buf[256];
+
+ gdk_threads_enter();
+
+ gfio_set_connected(gc->ge, 0);
+ clear_ge_ui_info(gc->ge);
+
+ sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
+
+ dialog = gtk_dialog_new_with_buttons("Timed out!",
+ GTK_WINDOW(main_ui.window),
+ GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
+
+ /* gtk_dialog_get_content_area() is 2.14 and newer */
+ content = GTK_DIALOG(dialog)->vbox;
+
+ label = gtk_label_new((const gchar *) buf);
+ gtk_container_add(GTK_CONTAINER(content), label);
+ gtk_widget_show_all(dialog);
+ gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
+
+ gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+
+ gdk_threads_leave();
+}
+
+static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct gfio_client *gc = client->client_data;
+
+ gdk_threads_enter();
+
+ gfio_set_connected(gc->ge, 0);
+
+ if (gc->err_entry)
+ entry_set_int_value(gc->err_entry, client->error);
+
+ gdk_threads_leave();
+}
+
+struct client_ops gfio_client_ops = {
+ .text_op = gfio_text_op,
+ .disk_util = gfio_disk_util_op,
+ .thread_status = gfio_thread_status_op,
+ .group_stats = gfio_group_stats_op,
+ .jobs_eta = gfio_update_client_eta,
+ .eta = gfio_update_all_eta,
+ .probe = gfio_probe_op,
+ .quit = gfio_quit_op,
+ .add_job = gfio_add_job_op,
+ .timed_out = gfio_client_timed_out,
+ .stop = gfio_client_stop,
+ .eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
+ .stay_connected = 1,
+};
+
+static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
+ __attribute__((unused)) gpointer data)
+{
+ gtk_main_quit();
+}
+
+static void *job_thread(void *arg)
+{
+ struct gui *ui = arg;
+
+ ui->handler_running = 1;
+ fio_handle_clients(&gfio_client_ops);
+ ui->handler_running = 0;
+ return NULL;
+}
+
+static int send_job_files(struct gui_entry *ge)
+{
+ struct gfio_client *gc = ge->client;
+ int i, ret = 0;
+
+ for (i = 0; i < ge->nr_job_files; i++) {
+ ret = fio_client_send_ini(gc->client, ge->job_files[i]);
+ if (ret < 0) {
+ GError *error;
+
+ error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret));
+ report_error(error);
+ g_error_free(error);
+ break;
+ } else if (ret)
+ break;
+
+ free(ge->job_files[i]);
+ ge->job_files[i] = NULL;
+ }
+ while (i < ge->nr_job_files) {
+ free(ge->job_files[i]);
+ ge->job_files[i] = NULL;
+ i++;
+ }
+
+ return ret;
+}
+
+static void *server_thread(void *arg)
+{
+ is_backend = 1;
+ gfio_server_running = 1;
+ fio_start_server(NULL);
+ gfio_server_running = 0;
+ return NULL;
+}
+
+static void gfio_start_server(void)
+{
+ struct gui *ui = &main_ui;
+
+ if (!gfio_server_running) {
+ gfio_server_running = 1;
+ pthread_create(&ui->server_t, NULL, server_thread, NULL);
+ pthread_detach(ui->server_t);
+ }
+}
+
+static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
+ gpointer data)
+{
+ struct gui_entry *ge = data;
+ struct gfio_client *gc = ge->client;
+
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
+ fio_start_client(gc->client);
+}
+
+static void file_open(GtkWidget *w, gpointer data);
+
+static void connect_clicked(GtkWidget *widget, gpointer data)
+{
+ struct gui_entry *ge = data;
+ struct gfio_client *gc = ge->client;