2 * gfio - gui front end for fio - the flexible io tester
4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
5 * Copyright (C) 2012 Jens Axboe <axboe@kernel.dk>
7 * The license below covers all files distributed with fio unless otherwise
8 * noted in the file itself.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
34 static int gfio_server_running;
35 static const char *gfio_graph_font;
37 static void gfio_update_thread_status(char *status_message, double perc);
39 #define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
41 typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
43 static void connect_clicked(GtkWidget *widget, gpointer data);
44 static void start_job_clicked(GtkWidget *widget, gpointer data);
46 static struct button_spec {
47 const char *buttontext;
49 const char *tooltiptext;
50 const int start_insensitive;
51 } buttonspeclist[] = {
52 #define CONNECT_BUTTON 0
53 #define START_JOB_BUTTON 1
54 { "Connect", connect_clicked, "Connect to host", 0 },
57 "Send current fio job to fio server to be executed", 1 },
79 GtkWidget *write_iops;
89 GtkWidget *bottomalign;
90 GtkWidget *thread_status_pb;
92 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
93 GtkWidget *scrolled_window;
94 #define DRAWING_AREA_XDIM 1000
95 #define DRAWING_AREA_YDIM 400
96 GtkWidget *drawing_area;
97 GtkWidget *error_info_bar;
98 GtkWidget *error_label;
99 GtkWidget *results_notebook;
100 GtkWidget *results_window;
101 GtkListStore *log_model;
105 struct probe_widget probe;
106 struct eta_widget eta;
111 struct graph *iops_graph;
112 struct graph *bandwidth_graph;
113 struct fio_client *client;
120 GtkWidget *results_widget;
121 GtkWidget *disk_util_frame;
124 static void add_invisible_data(struct graph *g)
127 * This puts some invisible data into a graph so that it will
128 * initially have some grid lines instead of "No good data"
130 graph_add_label(g, "invisible");
131 graph_set_color(g, "invisible", INVISIBLE_COLOR, 0.0, 0.7);
132 graph_add_xy_data(g, "invisible", 0.0, 0.0);
133 graph_add_xy_data(g, "invisible", 1.0, 100.0);
136 static void setup_iops_graph(struct gui *ui)
139 graph_free(ui->iops_graph);
140 ui->iops_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
141 DRAWING_AREA_YDIM, gfio_graph_font);
142 graph_title(ui->iops_graph, "IOPS");
143 graph_x_title(ui->iops_graph, "Time (secs)");
144 graph_add_label(ui->iops_graph, "Read IOPS");
145 graph_add_label(ui->iops_graph, "Write IOPS");
146 graph_set_color(ui->iops_graph, "Read IOPS", 0.7, 0.0, 0.0);
147 graph_set_color(ui->iops_graph, "Write IOPS", 0.0, 0.0, 0.7);
148 add_invisible_data(ui->iops_graph);
151 static void setup_bandwidth_graph(struct gui *ui)
153 if (ui->bandwidth_graph)
154 graph_free(ui->bandwidth_graph);
155 ui->bandwidth_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
156 DRAWING_AREA_YDIM, gfio_graph_font);
157 graph_title(ui->bandwidth_graph, "Bandwidth");
158 graph_x_title(ui->bandwidth_graph, "Time (secs)");
159 graph_add_label(ui->bandwidth_graph, "Read Bandwidth");
160 graph_add_label(ui->bandwidth_graph, "Write Bandwidth");
161 graph_set_color(ui->bandwidth_graph, "Read Bandwidth", 0.7, 0.0, 0.0);
162 graph_set_color(ui->bandwidth_graph, "Write Bandwidth", 0.0, 0.0, 0.7);
163 add_invisible_data(ui->bandwidth_graph);
166 static void clear_ui_info(struct gui *ui)
168 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
169 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
170 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
171 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
172 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
173 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
174 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
175 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
176 gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
177 gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
178 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
179 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
180 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
181 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
184 static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
186 GtkWidget *entry, *frame;
188 frame = gtk_frame_new(label);
189 entry = gtk_entry_new();
190 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
191 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
192 gtk_container_add(GTK_CONTAINER(frame), entry);
197 static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
199 GtkWidget *label_widget;
202 frame = gtk_frame_new(label);
203 label_widget = gtk_label_new(NULL);
204 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
205 gtk_container_add(GTK_CONTAINER(frame), label_widget);
210 static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
212 GtkWidget *button, *box;
214 box = gtk_hbox_new(FALSE, 3);
215 gtk_container_add(GTK_CONTAINER(hbox), box);
217 button = gtk_spin_button_new_with_range(min, max, 1.0);
218 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
220 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
221 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
226 static void gfio_set_connected(struct gui *ui, int connected)
229 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
231 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
232 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
235 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
236 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
237 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
241 static void label_set_int_value(GtkWidget *entry, unsigned int val)
245 sprintf(tmp, "%u", val);
246 gtk_label_set_text(GTK_LABEL(entry), tmp);
249 static void entry_set_int_value(GtkWidget *entry, unsigned int val)
253 sprintf(tmp, "%u", val);
254 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
258 #define ALIGN_RIGHT 2
262 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
264 GtkCellRenderer *renderer;
265 GtkTreeViewColumn *col;
266 double xalign = 0.0; /* left as default */
267 PangoAlignment align;
270 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
271 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
273 visible = !(flags & INVISIBLE);
275 renderer = gtk_cell_renderer_text_new();
276 col = gtk_tree_view_column_new();
278 gtk_tree_view_column_set_title(col, title);
279 if (!(flags & UNSORTABLE))
280 gtk_tree_view_column_set_sort_column_id(col, index);
281 gtk_tree_view_column_set_resizable(col, TRUE);
282 gtk_tree_view_column_pack_start(col, renderer, TRUE);
283 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
284 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
286 case PANGO_ALIGN_LEFT:
289 case PANGO_ALIGN_CENTER:
292 case PANGO_ALIGN_RIGHT:
296 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
297 gtk_tree_view_column_set_visible(col, visible);
298 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
302 static void gfio_ui_setup_log(struct gui *ui)
304 GtkTreeSelection *selection;
306 GtkWidget *tree_view;
308 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
310 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
311 gtk_widget_set_can_focus(tree_view, FALSE);
313 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
314 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
315 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
316 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
318 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
319 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
320 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
321 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
323 ui->log_model = model;
324 ui->log_tree = tree_view;
327 static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
333 GType types[FIO_IO_U_LIST_MAX_LEN];
334 GtkWidget *tree_view;
335 GtkTreeSelection *selection;
340 for (i = 0; i < len; i++)
341 types[i] = G_TYPE_INT;
343 model = gtk_list_store_newv(len, types);
345 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
346 gtk_widget_set_can_focus(tree_view, FALSE);
348 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
349 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
351 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
352 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
354 for (i = 0; i < len; i++) {
357 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
358 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
361 gtk_list_store_append(model, &iter);
363 for (i = 0; i < len; i++) {
365 ovals[i] = (ovals[i] + 999) / 1000;
366 gtk_list_store_set(model, &iter, i, ovals[i], -1);
372 static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
375 unsigned int *io_u_plat = ts->io_u_plat[ddir];
376 unsigned long nr = ts->clat_stat[ddir].samples;
377 fio_fp64_t *plist = ts->percentile_list;
378 unsigned int *ovals, len, minv, maxv, scale_down;
380 GtkWidget *tree_view, *frame, *hbox;
383 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
388 * We default to usecs, but if the value range is such that we
389 * should scale down to msecs, do that.
391 if (minv > 2000 && maxv > 99999) {
399 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
401 sprintf(tmp, "Completion percentiles (%s)", base);
402 frame = gtk_frame_new(tmp);
403 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
405 hbox = gtk_hbox_new(FALSE, 3);
406 gtk_container_add(GTK_CONTAINER(frame), hbox);
408 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
414 static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
415 unsigned long max, double mean, double dev)
417 const char *base = "(usec)";
418 GtkWidget *hbox, *label, *frame;
422 if (!usec_to_msec(&min, &max, &mean, &dev))
425 minp = num2str(min, 6, 1, 0);
426 maxp = num2str(max, 6, 1, 0);
428 sprintf(tmp, "%s %s", name, base);
429 frame = gtk_frame_new(tmp);
430 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
432 hbox = gtk_hbox_new(FALSE, 3);
433 gtk_container_add(GTK_CONTAINER(frame), hbox);
435 label = new_info_label_in_frame(hbox, "Minimum");
436 gtk_label_set_text(GTK_LABEL(label), minp);
437 label = new_info_label_in_frame(hbox, "Maximum");
438 gtk_label_set_text(GTK_LABEL(label), maxp);
439 label = new_info_label_in_frame(hbox, "Average");
440 sprintf(tmp, "%5.02f", mean);
441 gtk_label_set_text(GTK_LABEL(label), tmp);
442 label = new_info_label_in_frame(hbox, "Standard deviation");
443 sprintf(tmp, "%5.02f", dev);
444 gtk_label_set_text(GTK_LABEL(label), tmp);
455 static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
456 struct thread_stat *ts, int ddir)
458 const char *ddir_label[2] = { "Read", "Write" };
459 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
460 unsigned long min[3], max[3], runt;
461 unsigned long long bw, iops;
462 unsigned int flags = 0;
463 double mean[3], dev[3];
464 char *io_p, *bw_p, *iops_p;
467 if (!ts->runtime[ddir])
470 i2p = is_power_of_2(rs->kb_base);
471 runt = ts->runtime[ddir];
473 bw = (1000 * ts->io_bytes[ddir]) / runt;
474 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
475 bw_p = num2str(bw, 6, 1, i2p);
477 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
478 iops_p = num2str(iops, 6, 1, 0);
480 box = gtk_hbox_new(FALSE, 3);
481 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
483 frame = gtk_frame_new(ddir_label[ddir]);
484 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
486 main_vbox = gtk_vbox_new(FALSE, 3);
487 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
489 box = gtk_hbox_new(FALSE, 3);
490 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
492 label = new_info_label_in_frame(box, "IO");
493 gtk_label_set_text(GTK_LABEL(label), io_p);
494 label = new_info_label_in_frame(box, "Bandwidth");
495 gtk_label_set_text(GTK_LABEL(label), bw_p);
496 label = new_info_label_in_frame(box, "IOPS");
497 gtk_label_set_text(GTK_LABEL(label), iops_p);
498 label = new_info_label_in_frame(box, "Runtime (msec)");
499 label_set_int_value(label, ts->runtime[ddir]);
501 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
502 double p_of_agg = 100.0;
503 const char *bw_str = "KB";
507 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
508 if (p_of_agg > 100.0)
512 if (mean[0] > 999999.9) {
520 sprintf(tmp, "Bandwidth (%s)", bw_str);
521 frame = gtk_frame_new(tmp);
522 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
524 box = gtk_hbox_new(FALSE, 3);
525 gtk_container_add(GTK_CONTAINER(frame), box);
527 label = new_info_label_in_frame(box, "Minimum");
528 label_set_int_value(label, min[0]);
529 label = new_info_label_in_frame(box, "Maximum");
530 label_set_int_value(label, max[0]);
531 label = new_info_label_in_frame(box, "Percentage of jobs");
532 sprintf(tmp, "%3.2f%%", p_of_agg);
533 gtk_label_set_text(GTK_LABEL(label), tmp);
534 label = new_info_label_in_frame(box, "Average");
535 sprintf(tmp, "%5.02f", mean[0]);
536 gtk_label_set_text(GTK_LABEL(label), tmp);
537 label = new_info_label_in_frame(box, "Standard deviation");
538 sprintf(tmp, "%5.02f", dev[0]);
539 gtk_label_set_text(GTK_LABEL(label), tmp);
542 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
544 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
546 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
550 frame = gtk_frame_new("Latency");
551 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
553 vbox = gtk_vbox_new(FALSE, 3);
554 gtk_container_add(GTK_CONTAINER(frame), vbox);
556 if (flags & GFIO_SLAT)
557 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
558 if (flags & GFIO_CLAT)
559 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
560 if (flags & GFIO_LAT)
561 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
564 if (ts->clat_percentiles)
565 gfio_show_clat_percentiles(main_vbox, ts, ddir);
573 static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
576 GtkWidget *tree_view;
577 GtkTreeSelection *selection;
584 * Check if all are empty, in which case don't bother
586 for (i = 0, skipped = 0; i < num; i++)
593 types = malloc(num * sizeof(GType));
595 for (i = 0; i < num; i++)
596 types[i] = G_TYPE_STRING;
598 model = gtk_list_store_newv(num, types);
602 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
603 gtk_widget_set_can_focus(tree_view, FALSE);
605 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
606 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
608 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
609 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
611 for (i = 0; i < num; i++)
612 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
614 gtk_list_store_append(model, &iter);
616 for (i = 0; i < num; i++) {
620 sprintf(fbuf, "0.00");
622 sprintf(fbuf, "%3.2f%%", lat[i]);
624 gtk_list_store_set(model, &iter, i, fbuf, -1);
630 static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
632 GtkWidget *box, *frame, *tree_view;
633 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
634 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
635 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
636 "250", "500", "750", "1000", };
637 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
638 "250", "500", "750", "1000", "2000",
641 stat_calc_lat_u(ts, io_u_lat_u);
642 stat_calc_lat_m(ts, io_u_lat_m);
644 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
646 frame = gtk_frame_new("Latency buckets (usec)");
647 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
649 box = gtk_hbox_new(FALSE, 3);
650 gtk_container_add(GTK_CONTAINER(frame), box);
651 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
654 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
656 frame = gtk_frame_new("Latency buckets (msec)");
657 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
659 box = gtk_hbox_new(FALSE, 3);
660 gtk_container_add(GTK_CONTAINER(frame), box);
661 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
665 static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
667 GtkWidget *box, *frame, *entry;
668 double usr_cpu, sys_cpu;
669 unsigned long runtime;
672 runtime = ts->total_run_time;
674 double runt = (double) runtime;
676 usr_cpu = (double) ts->usr_time * 100 / runt;
677 sys_cpu = (double) ts->sys_time * 100 / runt;
683 frame = gtk_frame_new("OS resources");
684 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
686 box = gtk_hbox_new(FALSE, 3);
687 gtk_container_add(GTK_CONTAINER(frame), box);
689 entry = new_info_entry_in_frame(box, "User CPU");
690 sprintf(tmp, "%3.2f%%", usr_cpu);
691 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
692 entry = new_info_entry_in_frame(box, "System CPU");
693 sprintf(tmp, "%3.2f%%", sys_cpu);
694 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
695 entry = new_info_entry_in_frame(box, "Context switches");
696 entry_set_int_value(entry, ts->ctx);
697 entry = new_info_entry_in_frame(box, "Major faults");
698 entry_set_int_value(entry, ts->majf);
699 entry = new_info_entry_in_frame(box, "Minor faults");
700 entry_set_int_value(entry, ts->minf);
702 static void gfio_add_sc_depths_tree(GtkListStore *model,
703 struct thread_stat *ts, unsigned int len,
706 double io_u_dist[FIO_IO_U_MAP_NR];
708 /* Bits 0, and 3-8 */
709 const int add_mask = 0x1f9;
713 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
715 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
717 gtk_list_store_append(model, &iter);
719 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
721 for (i = 1, j = 0; i < len; i++) {
724 if (!(add_mask & (1UL << (i - 1))))
725 sprintf(fbuf, "0.0%%");
727 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
731 gtk_list_store_set(model, &iter, i, fbuf, -1);
736 static void gfio_add_total_depths_tree(GtkListStore *model,
737 struct thread_stat *ts, unsigned int len)
739 double io_u_dist[FIO_IO_U_MAP_NR];
741 /* Bits 1-6, and 8 */
742 const int add_mask = 0x17e;
745 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
747 gtk_list_store_append(model, &iter);
749 gtk_list_store_set(model, &iter, 0, "Total", -1);
751 for (i = 1, j = 0; i < len; i++) {
754 if (!(add_mask & (1UL << (i - 1))))
755 sprintf(fbuf, "0.0%%");
757 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
761 gtk_list_store_set(model, &iter, i, fbuf, -1);
766 static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
768 GtkWidget *frame, *box, *tree_view;
769 GtkTreeSelection *selection;
771 GType types[FIO_IO_U_MAP_NR + 1];
774 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
776 frame = gtk_frame_new("IO depths");
777 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
779 box = gtk_hbox_new(FALSE, 3);
780 gtk_container_add(GTK_CONTAINER(frame), box);
782 for (i = 0; i < NR_LABELS; i++)
783 types[i] = G_TYPE_STRING;
785 model = gtk_list_store_newv(NR_LABELS, types);
787 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
788 gtk_widget_set_can_focus(tree_view, FALSE);
790 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
791 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
793 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
794 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
796 for (i = 0; i < NR_LABELS; i++)
797 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
799 gfio_add_total_depths_tree(model, ts, NR_LABELS);
800 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
801 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
803 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
806 static gboolean results_window_delete(GtkWidget *w, gpointer data)
808 struct gui *ui = (struct gui *) data;
810 gtk_widget_destroy(w);
811 ui->results_window = NULL;
812 ui->results_notebook = NULL;
816 static GtkWidget *get_results_window(struct gui *ui)
818 GtkWidget *win, *notebook;
820 if (ui->results_window)
821 return ui->results_notebook;
823 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
824 gtk_window_set_title(GTK_WINDOW(win), "Results");
825 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ui);
826 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ui);
828 notebook = gtk_notebook_new();
829 gtk_container_add(GTK_CONTAINER(win), notebook);
831 ui->results_window = win;
832 ui->results_notebook = notebook;
833 return ui->results_notebook;
836 static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
837 struct group_run_stats *rs)
839 GtkWidget *res_win, *box, *vbox, *entry;
840 struct gfio_client *gc = client->client_data;
844 res_win = get_results_window(gc->ui);
846 vbox = gtk_vbox_new(FALSE, 3);
848 box = gtk_hbox_new(TRUE, 3);
849 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
851 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), vbox, gtk_label_new(ts->name));
853 gc->results_widget = vbox;
855 entry = new_info_entry_in_frame(box, "Name");
856 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
857 if (strlen(ts->description)) {
858 entry = new_info_entry_in_frame(box, "Description");
859 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
861 entry = new_info_entry_in_frame(box, "Group ID");
862 entry_set_int_value(entry, ts->groupid);
863 entry = new_info_entry_in_frame(box, "Jobs");
864 entry_set_int_value(entry, ts->members);
865 entry = new_info_entry_in_frame(box, "Error");
866 entry_set_int_value(entry, ts->error);
867 entry = new_info_entry_in_frame(box, "PID");
868 entry_set_int_value(entry, ts->pid);
870 if (ts->io_bytes[DDIR_READ])
871 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
872 if (ts->io_bytes[DDIR_WRITE])
873 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
875 gfio_show_latency_buckets(vbox, ts);
876 gfio_show_cpu_usage(vbox, ts);
877 gfio_show_io_depths(vbox, ts);
879 gtk_widget_show_all(gc->ui->results_window);
883 static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
885 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
886 struct gfio_client *gc = client->client_data;
890 char tmp[64], timebuf[80];
893 tm = localtime(&sec);
894 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
895 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
899 gtk_list_store_append(gc->ui->log_model, &iter);
900 gtk_list_store_set(gc->ui->log_model, &iter, 0, timebuf, -1);
901 gtk_list_store_set(gc->ui->log_model, &iter, 1, client->hostname, -1);
902 gtk_list_store_set(gc->ui->log_model, &iter, 2, p->level, -1);
903 gtk_list_store_set(gc->ui->log_model, &iter, 3, p->buf, -1);
908 static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
910 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
911 struct gfio_client *gc = client->client_data;
912 GtkWidget *box, *frame, *entry, *vbox;
916 if (!gc->results_widget) {
917 printf("no results!\n");
921 if (!gc->disk_util_frame) {
922 gc->disk_util_frame = gtk_frame_new("Disk utilization");
923 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
926 vbox = gtk_vbox_new(FALSE, 3);
927 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
929 frame = gtk_frame_new((char *) p->dus.name);
930 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
932 box = gtk_vbox_new(FALSE, 3);
933 gtk_container_add(GTK_CONTAINER(frame), box);
935 frame = gtk_frame_new("Read");
936 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
937 vbox = gtk_hbox_new(TRUE, 3);
938 gtk_container_add(GTK_CONTAINER(frame), vbox);
939 entry = new_info_entry_in_frame(vbox, "IOs");
940 entry_set_int_value(entry, p->dus.ios[0]);
941 entry = new_info_entry_in_frame(vbox, "Merges");
942 entry_set_int_value(entry, p->dus.merges[0]);
943 entry = new_info_entry_in_frame(vbox, "Sectors");
944 entry_set_int_value(entry, p->dus.sectors[0]);
945 entry = new_info_entry_in_frame(vbox, "Ticks");
946 entry_set_int_value(entry, p->dus.ticks[0]);
948 frame = gtk_frame_new("Write");
949 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
950 vbox = gtk_hbox_new(TRUE, 3);
951 gtk_container_add(GTK_CONTAINER(frame), vbox);
952 entry = new_info_entry_in_frame(vbox, "IOs");
953 entry_set_int_value(entry, p->dus.ios[1]);
954 entry = new_info_entry_in_frame(vbox, "Merges");
955 entry_set_int_value(entry, p->dus.merges[1]);
956 entry = new_info_entry_in_frame(vbox, "Sectors");
957 entry_set_int_value(entry, p->dus.sectors[1]);
958 entry = new_info_entry_in_frame(vbox, "Ticks");
959 entry_set_int_value(entry, p->dus.ticks[1]);
961 frame = gtk_frame_new("Shared");
962 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
963 vbox = gtk_hbox_new(TRUE, 3);
964 gtk_container_add(GTK_CONTAINER(frame), vbox);
965 entry = new_info_entry_in_frame(vbox, "IO ticks");
966 entry_set_int_value(entry, p->dus.io_ticks);
967 entry = new_info_entry_in_frame(vbox, "Time in queue");
968 entry_set_int_value(entry, p->dus.time_in_queue);
970 gtk_widget_show_all(gc->results_widget);
975 extern int sum_stat_clients;
976 extern struct thread_stat client_ts;
977 extern struct group_run_stats client_gs;
979 static int sum_stat_nr;
981 static void gfio_thread_status_op(struct fio_client *client,
982 struct fio_net_cmd *cmd)
984 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
986 gfio_display_ts(client, &p->ts, &p->rs);
988 if (sum_stat_clients == 1)
991 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
992 sum_group_stats(&client_gs, &p->rs);
995 client_ts.groupid = p->ts.groupid;
997 if (++sum_stat_nr == sum_stat_clients) {
998 strcpy(client_ts.name, "All clients");
999 gfio_display_ts(client, &client_ts, &client_gs);
1003 static void gfio_group_stats_op(struct fio_client *client,
1004 struct fio_net_cmd *cmd)
1006 gdk_threads_enter();
1007 printf("gfio_group_stats_op called\n");
1008 fio_client_ops.group_stats(client, cmd);
1009 gdk_threads_leave();
1012 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1014 struct gui *ui = (struct gui *) p;
1017 cr = gdk_cairo_create(w->window);
1019 cairo_set_source_rgb(cr, 0, 0, 0);
1022 cairo_translate(cr, 0, 0);
1023 line_graph_draw(ui->bandwidth_graph, cr);
1028 cairo_translate(cr, DRAWING_AREA_XDIM / 2.0, 0);
1029 // DRAWING_AREA_YDIM * 0.05);
1030 line_graph_draw(ui->iops_graph, cr);
1038 static void gfio_update_eta(struct jobs_eta *je)
1040 static int eta_good;
1047 gdk_threads_enter();
1052 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1053 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1054 eta_to_str(eta_str, je->eta_sec);
1057 sprintf(tmp, "%u", je->nr_running);
1058 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
1059 sprintf(tmp, "%u", je->files_open);
1060 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
1063 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1064 if (je->m_rate || je->t_rate) {
1067 mr = num2str(je->m_rate, 4, 0, i2p);
1068 tr = num2str(je->t_rate, 4, 0, i2p);
1069 gtk_entry_set_text(GTK_ENTRY(ui.eta);
1070 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1073 } else if (je->m_iops || je->t_iops)
1074 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1076 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
1077 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
1078 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
1079 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
1082 if (je->eta_sec != INT_MAX && je->nr_running) {
1086 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1087 strcpy(output, "-.-% done");
1091 sprintf(output, "%3.1f%% done", perc);
1094 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1095 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1097 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1098 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1100 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
1101 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
1102 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
1103 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
1105 graph_add_xy_data(ui.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
1106 graph_add_xy_data(ui.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
1107 graph_add_xy_data(ui.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
1108 graph_add_xy_data(ui.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
1117 char *dst = output + strlen(output);
1119 sprintf(dst, " - %s", eta_str);
1122 gfio_update_thread_status(output, perc);
1123 gdk_threads_leave();
1126 static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1128 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
1129 struct gfio_client *gc = client->client_data;
1130 struct gui *ui = gc->ui;
1131 const char *os, *arch;
1134 os = fio_get_os_string(probe->os);
1138 arch = fio_get_arch_string(probe->arch);
1143 client->name = strdup((char *) probe->hostname);
1145 gdk_threads_enter();
1147 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), (char *) probe->hostname);
1148 gtk_label_set_text(GTK_LABEL(ui->probe.os), os);
1149 gtk_label_set_text(GTK_LABEL(ui->probe.arch), arch);
1150 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
1151 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), buf);
1153 gfio_set_connected(ui, 1);
1155 gdk_threads_leave();
1158 static void gfio_update_thread_status(char *status_message, double perc)
1160 static char message[100];
1161 const char *m = message;
1163 strncpy(message, status_message, sizeof(message) - 1);
1164 gtk_progress_bar_set_text(
1165 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
1166 gtk_progress_bar_set_fraction(
1167 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
1168 gtk_widget_queue_draw(ui.window);
1171 static void gfio_quit_op(struct fio_client *client)
1173 struct gfio_client *gc = client->client_data;
1175 gdk_threads_enter();
1176 gfio_set_connected(gc->ui, 0);
1177 gdk_threads_leave();
1180 static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1182 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
1183 struct gfio_client *gc = client->client_data;
1184 struct gui *ui = gc->ui;
1188 p->iodepth = le32_to_cpu(p->iodepth);
1189 p->rw = le32_to_cpu(p->rw);
1191 for (i = 0; i < 2; i++) {
1192 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
1193 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
1196 p->numjobs = le32_to_cpu(p->numjobs);
1197 p->group_reporting = le32_to_cpu(p->group_reporting);
1199 gdk_threads_enter();
1201 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
1202 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
1203 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
1205 sprintf(tmp, "%u", p->iodepth);
1206 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
1208 gdk_threads_leave();
1211 static void gfio_client_timed_out(struct fio_client *client)
1213 struct gfio_client *gc = client->client_data;
1214 GtkWidget *dialog, *label, *content;
1217 gdk_threads_enter();
1219 gfio_set_connected(gc->ui, 0);
1220 clear_ui_info(gc->ui);
1222 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1224 dialog = gtk_dialog_new_with_buttons("Timed out!",
1225 GTK_WINDOW(gc->ui->window),
1226 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1227 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
1229 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1230 label = gtk_label_new((const gchar *) buf);
1231 gtk_container_add(GTK_CONTAINER(content), label);
1232 gtk_widget_show_all(dialog);
1233 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1235 gtk_dialog_run(GTK_DIALOG(dialog));
1236 gtk_widget_destroy(dialog);
1238 gdk_threads_leave();
1241 struct client_ops gfio_client_ops = {
1242 .text_op = gfio_text_op,
1243 .disk_util = gfio_disk_util_op,
1244 .thread_status = gfio_thread_status_op,
1245 .group_stats = gfio_group_stats_op,
1246 .eta = gfio_update_eta,
1247 .probe = gfio_probe_op,
1248 .quit = gfio_quit_op,
1249 .add_job = gfio_add_job_op,
1250 .timed_out = gfio_client_timed_out,
1251 .stay_connected = 1,
1254 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1255 __attribute__((unused)) gpointer data)
1260 static void *job_thread(void *arg)
1262 fio_handle_clients(&gfio_client_ops);
1266 static int send_job_files(struct gui *ui)
1270 for (i = 0; i < ui->nr_job_files; i++) {
1271 ret = fio_clients_send_ini(ui->job_files[i]);
1275 free(ui->job_files[i]);
1276 ui->job_files[i] = NULL;
1278 while (i < ui->nr_job_files) {
1279 free(ui->job_files[i]);
1280 ui->job_files[i] = NULL;
1287 static void start_job_thread(struct gui *ui)
1289 if (send_job_files(ui)) {
1290 printf("Yeah, I didn't really like those options too much.\n");
1291 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
1296 static void *server_thread(void *arg)
1299 gfio_server_running = 1;
1300 fio_start_server(NULL);
1301 gfio_server_running = 0;
1305 static void gfio_start_server(struct gui *ui)
1307 if (!gfio_server_running) {
1308 gfio_server_running = 1;
1309 pthread_create(&ui->server_t, NULL, server_thread, NULL);
1310 pthread_detach(ui->server_t);
1314 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
1317 struct gui *ui = data;
1319 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
1320 start_job_thread(ui);
1323 static void file_open(GtkWidget *w, gpointer data);
1325 static void connect_clicked(GtkWidget *widget, gpointer data)
1327 struct gui *ui = data;
1329 if (!ui->connected) {
1330 if (!ui->nr_job_files)
1331 file_open(widget, data);
1332 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
1333 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1334 if (!fio_clients_connect()) {
1335 pthread_create(&ui->t, NULL, job_thread, NULL);
1336 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 0);
1339 fio_clients_terminate();
1340 gfio_set_connected(ui, 0);
1345 static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
1346 struct button_spec *buttonspec)
1348 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
1349 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
1350 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
1351 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
1352 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
1355 static void add_buttons(struct gui *ui,
1356 struct button_spec *buttonlist,
1361 for (i = 0; i < nbuttons; i++)
1362 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
1365 static void on_info_bar_response(GtkWidget *widget, gint response,
1368 if (response == GTK_RESPONSE_OK) {
1369 gtk_widget_destroy(widget);
1370 ui.error_info_bar = NULL;
1374 void report_error(GError *error)
1376 if (ui.error_info_bar == NULL) {
1377 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1380 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1381 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
1384 ui.error_label = gtk_label_new(error->message);
1385 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
1386 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
1388 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
1389 gtk_widget_show_all(ui.vbox);
1392 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1393 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
1397 struct connection_widgets
1404 static void hostname_cb(GtkEntry *entry, gpointer data)
1406 struct connection_widgets *cw = data;
1407 int uses_net = 0, is_localhost = 0;
1412 * Check whether to display the 'auto start backend' box
1413 * or not. Show it if we are a localhost and using network,
1414 * or using a socket.
1416 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1417 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1422 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1423 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1424 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1425 !strcmp(text, "ip6-loopback"))
1429 if (!uses_net || is_localhost) {
1430 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1431 gtk_widget_set_sensitive(cw->button, 1);
1433 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1434 gtk_widget_set_sensitive(cw->button, 0);
1438 static int get_connection_details(char **host, int *port, int *type,
1441 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1442 struct connection_widgets cw;
1445 dialog = gtk_dialog_new_with_buttons("Connection details",
1446 GTK_WINDOW(ui.window),
1447 GTK_DIALOG_DESTROY_WITH_PARENT,
1448 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1449 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1451 frame = gtk_frame_new("Hostname / socket name");
1452 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1453 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1455 box = gtk_vbox_new(FALSE, 6);
1456 gtk_container_add(GTK_CONTAINER(frame), box);
1458 hbox = gtk_hbox_new(TRUE, 10);
1459 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1460 cw.hentry = gtk_entry_new();
1461 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
1462 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
1464 frame = gtk_frame_new("Port");
1465 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1466 box = gtk_vbox_new(FALSE, 10);
1467 gtk_container_add(GTK_CONTAINER(frame), box);
1469 hbox = gtk_hbox_new(TRUE, 4);
1470 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1471 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1473 frame = gtk_frame_new("Type");
1474 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1475 box = gtk_vbox_new(FALSE, 10);
1476 gtk_container_add(GTK_CONTAINER(frame), box);
1478 hbox = gtk_hbox_new(TRUE, 4);
1479 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1481 cw.combo = gtk_combo_box_new_text();
1482 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
1483 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
1484 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
1485 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
1487 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
1489 frame = gtk_frame_new("Options");
1490 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1491 box = gtk_vbox_new(FALSE, 10);
1492 gtk_container_add(GTK_CONTAINER(frame), box);
1494 hbox = gtk_hbox_new(TRUE, 4);
1495 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1497 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1498 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
1499 gtk_widget_set_tooltip_text(cw.button, "When running fio locally, it is necessary to have the backend running on the same system. If this is checked, gfio will start the backend automatically for you if it isn't already running.");
1500 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
1503 * Connect edit signal, so we can show/not-show the auto start button
1505 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
1506 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
1508 gtk_widget_show_all(dialog);
1510 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1511 gtk_widget_destroy(dialog);
1515 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
1516 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1518 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
1519 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1520 *type = Fio_client_ipv4;
1521 else if (!strncmp(typeentry, "IPv6", 4))
1522 *type = Fio_client_ipv6;
1524 *type = Fio_client_socket;
1527 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
1529 gtk_widget_destroy(dialog);
1533 static void gfio_client_added(struct gui *ui, struct fio_client *client)
1535 struct gfio_client *gc;
1537 gc = malloc(sizeof(*gc));
1538 memset(gc, 0, sizeof(*gc));
1541 client->client_data = gc;
1544 static void file_open(GtkWidget *w, gpointer data)
1547 struct gui *ui = data;
1548 GSList *filenames, *fn_glist;
1549 GtkFileFilter *filter;
1551 int port, type, server_start;
1553 dialog = gtk_file_chooser_dialog_new("Open File",
1554 GTK_WINDOW(ui->window),
1555 GTK_FILE_CHOOSER_ACTION_OPEN,
1556 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1557 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1559 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1561 filter = gtk_file_filter_new();
1562 gtk_file_filter_add_pattern(filter, "*.fio");
1563 gtk_file_filter_add_pattern(filter, "*.job");
1564 gtk_file_filter_add_pattern(filter, "*.ini");
1565 gtk_file_filter_add_mime_type(filter, "text/fio");
1566 gtk_file_filter_set_name(filter, "Fio job file");
1567 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1569 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1570 gtk_widget_destroy(dialog);
1574 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
1576 gtk_widget_destroy(dialog);
1578 if (get_connection_details(&host, &port, &type, &server_start))
1581 filenames = fn_glist;
1582 while (filenames != NULL) {
1583 struct fio_client *client;
1585 ui->job_files = realloc(ui->job_files, (ui->nr_job_files + 1) * sizeof(char *));
1586 ui->job_files[ui->nr_job_files] = strdup(filenames->data);
1589 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
1593 error = g_error_new(g_quark_from_string("fio"), 1,
1594 "Failed to add client %s", host);
1595 report_error(error);
1596 g_error_free(error);
1598 gfio_client_added(ui, client);
1600 g_free(filenames->data);
1601 filenames = g_slist_next(filenames);
1606 gfio_start_server(ui);
1608 g_slist_free(fn_glist);
1611 static void file_save(GtkWidget *w, gpointer data)
1613 struct gui *ui = data;
1616 dialog = gtk_file_chooser_dialog_new("Save File",
1617 GTK_WINDOW(ui->window),
1618 GTK_FILE_CHOOSER_ACTION_SAVE,
1619 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1620 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1623 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1624 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1626 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1629 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1630 // save_job_file(filename);
1633 gtk_widget_destroy(dialog);
1636 static void view_log_destroy(GtkWidget *w, gpointer data)
1638 struct gui *ui = (struct gui *) data;
1640 gtk_widget_ref(ui->log_tree);
1641 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
1642 gtk_widget_destroy(w);
1643 ui->log_view = NULL;
1646 static void view_log(GtkWidget *w, gpointer data)
1648 GtkWidget *win, *scroll, *vbox, *box;
1649 struct gui *ui = (struct gui *) data;
1654 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1655 gtk_window_set_title(GTK_WINDOW(win), "Log");
1656 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
1658 scroll = gtk_scrolled_window_new(NULL, NULL);
1660 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1662 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1664 box = gtk_hbox_new(TRUE, 0);
1665 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
1666 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
1667 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
1669 vbox = gtk_vbox_new(TRUE, 5);
1670 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
1672 gtk_container_add(GTK_CONTAINER(win), vbox);
1673 gtk_widget_show_all(win);
1676 static void preferences(GtkWidget *w, gpointer data)
1678 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
1681 dialog = gtk_dialog_new_with_buttons("Preferences",
1682 GTK_WINDOW(ui.window),
1683 GTK_DIALOG_DESTROY_WITH_PARENT,
1684 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1685 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1688 frame = gtk_frame_new("Debug logging");
1689 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1691 vbox = gtk_vbox_new(FALSE, 6);
1692 gtk_container_add(GTK_CONTAINER(frame), vbox);
1694 box = gtk_hbox_new(FALSE, 6);
1695 gtk_container_add(GTK_CONTAINER(vbox), box);
1697 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1699 for (i = 0; i < FD_DEBUG_MAX; i++) {
1701 box = gtk_hbox_new(FALSE, 6);
1702 gtk_container_add(GTK_CONTAINER(vbox), box);
1706 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
1707 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
1708 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1711 frame = gtk_frame_new("Graph font");
1712 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1713 vbox = gtk_vbox_new(FALSE, 6);
1714 gtk_container_add(GTK_CONTAINER(frame), vbox);
1716 font = gtk_font_button_new();
1717 gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5);
1719 gtk_widget_show_all(dialog);
1721 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1722 gtk_widget_destroy(dialog);
1726 for (i = 0; i < FD_DEBUG_MAX; i++) {
1729 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1731 fio_debug |= (1UL << i);
1734 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
1735 printf("got font %s\n", gfio_graph_font);
1737 gtk_widget_destroy(dialog);
1740 static void about_dialog(GtkWidget *w, gpointer data)
1742 const char *authors[] = {
1743 "Jens Axboe <axboe@kernel.dk>",
1744 "Stephen Carmeron <stephenmcameron@gmail.com>",
1747 const char *license[] = {
1748 "Fio is free software; you can redistribute it and/or modify "
1749 "it under the terms of the GNU General Public License as published by "
1750 "the Free Software Foundation; either version 2 of the License, or "
1751 "(at your option) any later version.\n",
1752 "Fio is distributed in the hope that it will be useful, "
1753 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
1754 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
1755 "GNU General Public License for more details.\n",
1756 "You should have received a copy of the GNU General Public License "
1757 "along with Fio; if not, write to the Free Software Foundation, Inc., "
1758 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
1760 char *license_trans;
1762 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
1763 license[2], "\n", NULL);
1765 gtk_show_about_dialog(NULL,
1766 "program-name", "gfio",
1767 "comments", "Gtk2 UI for fio",
1768 "license", license_trans,
1769 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
1771 "version", fio_version_string,
1772 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
1773 "logo-icon-name", "fio",
1775 "wrap-license", TRUE,
1778 g_free (license_trans);
1781 static GtkActionEntry menu_items[] = {
1782 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1783 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
1784 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1785 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1786 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1787 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1788 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
1789 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1790 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
1792 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
1794 static const gchar *ui_string = " \
1796 <menubar name=\"MainMenu\"> \
1797 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1798 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1799 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1800 <separator name=\"Separator\"/> \
1801 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1802 <separator name=\"Separator2\"/> \
1803 <menuitem name=\"Quit\" action=\"Quit\" /> \
1805 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
1806 <menuitem name=\"Log\" action=\"ViewLog\" /> \
1808 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1809 <menuitem name=\"About\" action=\"About\" /> \
1815 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
1818 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1821 action_group = gtk_action_group_new("Menu");
1822 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
1824 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1825 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1827 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1828 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1831 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1832 GtkWidget *vbox, GtkUIManager *ui_manager)
1834 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1837 static void init_ui(int *argc, char **argv[], struct gui *ui)
1839 GtkSettings *settings;
1840 GtkUIManager *uimanager;
1841 GtkWidget *menu, *probe, *probe_frame, *probe_box;
1844 memset(ui, 0, sizeof(*ui));
1846 /* Magical g*thread incantation, you just need this thread stuff.
1847 * Without it, the update that happens in gfio_update_thread_status
1848 * doesn't really happen in a timely fashion, you need expose events
1850 if (!g_thread_supported())
1851 g_thread_init(NULL);
1854 gtk_init(argc, argv);
1855 settings = gtk_settings_get_default();
1856 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1859 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1860 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1861 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 700);
1863 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1864 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
1866 ui->vbox = gtk_vbox_new(FALSE, 0);
1867 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
1869 uimanager = gtk_ui_manager_new();
1870 menu = get_menubar_menu(ui->window, uimanager, ui);
1871 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1874 * Set up alignments for widgets at the top of ui,
1875 * align top left, expand horizontally but not vertically
1877 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
1878 ui->topvbox = gtk_vbox_new(FALSE, 3);
1879 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
1880 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
1882 probe = gtk_frame_new("Job");
1883 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1884 probe_frame = gtk_vbox_new(FALSE, 3);
1885 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1887 probe_box = gtk_hbox_new(FALSE, 3);
1888 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1889 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1890 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1891 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1892 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1894 probe_box = gtk_hbox_new(FALSE, 3);
1895 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1897 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1898 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1899 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1900 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1901 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1902 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
1904 probe_box = gtk_hbox_new(FALSE, 3);
1905 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1906 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1907 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1908 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1909 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
1912 * Only add this if we have a commit rate
1915 probe_box = gtk_hbox_new(FALSE, 3);
1916 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1918 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1919 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1921 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1922 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1926 * Set up a drawing area and IOPS and bandwidth graphs
1928 gdk_color_parse("white", &white);
1929 ui->drawing_area = gtk_drawing_area_new();
1930 gtk_widget_set_size_request(GTK_WIDGET(ui->drawing_area),
1931 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1932 gtk_widget_modify_bg(ui->drawing_area, GTK_STATE_NORMAL, &white);
1933 g_signal_connect(G_OBJECT(ui->drawing_area), "expose_event",
1934 G_CALLBACK (on_expose_drawing_area), ui);
1935 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1936 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1937 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1938 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1940 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1943 setup_iops_graph(ui);
1944 setup_bandwidth_graph(ui);
1947 * Set up alignments for widgets at the bottom of ui,
1948 * align bottom left, expand horizontally but not vertically
1950 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1951 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1952 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
1953 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1956 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
1959 * Set up thread status progress bar
1961 ui->thread_status_pb = gtk_progress_bar_new();
1962 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1963 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
1964 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1966 gfio_ui_setup_log(ui);
1968 gtk_widget_show_all(ui->window);
1971 int main(int argc, char *argv[], char *envp[])
1973 if (initialize_fio(envp))
1975 if (fio_init_options())
1978 init_ui(&argc, &argv, &ui);
1980 gdk_threads_enter();
1982 gdk_threads_leave();