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 setup_iops_graph(struct gui *ui)
127 graph_free(ui->iops_graph);
128 ui->iops_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
129 DRAWING_AREA_YDIM, gfio_graph_font);
130 graph_title(ui->iops_graph, "IOPS");
131 graph_x_title(ui->iops_graph, "Time (secs)");
132 graph_add_label(ui->iops_graph, "Read IOPS");
133 graph_add_label(ui->iops_graph, "Write IOPS");
134 graph_set_color(ui->iops_graph, "Read IOPS", 0.13, 0.54, 0.13);
135 graph_set_color(ui->iops_graph, "Write IOPS", 1.0, 0.0, 0.0);
136 line_graph_set_data_count_limit(ui->iops_graph, 100);
139 static void setup_bandwidth_graph(struct gui *ui)
141 if (ui->bandwidth_graph)
142 graph_free(ui->bandwidth_graph);
143 ui->bandwidth_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
144 DRAWING_AREA_YDIM, gfio_graph_font);
145 graph_title(ui->bandwidth_graph, "Bandwidth");
146 graph_x_title(ui->bandwidth_graph, "Time (secs)");
147 graph_add_label(ui->bandwidth_graph, "Read Bandwidth");
148 graph_add_label(ui->bandwidth_graph, "Write Bandwidth");
149 graph_set_color(ui->bandwidth_graph, "Read Bandwidth", 0.13, 0.54, 0.13);
150 graph_set_color(ui->bandwidth_graph, "Write Bandwidth", 1.0, 0.0, 0.0);
151 line_graph_set_data_count_limit(ui->bandwidth_graph, 100);
154 static void clear_ui_info(struct gui *ui)
156 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
157 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
158 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
159 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
160 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
161 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
162 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
163 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
164 gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
165 gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
166 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
167 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
168 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
169 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
172 static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
174 GtkWidget *entry, *frame;
176 frame = gtk_frame_new(label);
177 entry = gtk_entry_new();
178 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
179 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
180 gtk_container_add(GTK_CONTAINER(frame), entry);
185 static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
187 GtkWidget *label_widget;
190 frame = gtk_frame_new(label);
191 label_widget = gtk_label_new(NULL);
192 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
193 gtk_container_add(GTK_CONTAINER(frame), label_widget);
198 static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
200 GtkWidget *button, *box;
202 box = gtk_hbox_new(FALSE, 3);
203 gtk_container_add(GTK_CONTAINER(hbox), box);
205 button = gtk_spin_button_new_with_range(min, max, 1.0);
206 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
208 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
209 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
214 static void gfio_set_connected(struct gui *ui, int connected)
217 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
219 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
220 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
223 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
224 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
225 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
229 static void label_set_int_value(GtkWidget *entry, unsigned int val)
233 sprintf(tmp, "%u", val);
234 gtk_label_set_text(GTK_LABEL(entry), tmp);
237 static void entry_set_int_value(GtkWidget *entry, unsigned int val)
241 sprintf(tmp, "%u", val);
242 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
246 #define ALIGN_RIGHT 2
250 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
252 GtkCellRenderer *renderer;
253 GtkTreeViewColumn *col;
254 double xalign = 0.0; /* left as default */
255 PangoAlignment align;
258 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
259 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
261 visible = !(flags & INVISIBLE);
263 renderer = gtk_cell_renderer_text_new();
264 col = gtk_tree_view_column_new();
266 gtk_tree_view_column_set_title(col, title);
267 if (!(flags & UNSORTABLE))
268 gtk_tree_view_column_set_sort_column_id(col, index);
269 gtk_tree_view_column_set_resizable(col, TRUE);
270 gtk_tree_view_column_pack_start(col, renderer, TRUE);
271 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
272 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
274 case PANGO_ALIGN_LEFT:
277 case PANGO_ALIGN_CENTER:
280 case PANGO_ALIGN_RIGHT:
284 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
285 gtk_tree_view_column_set_visible(col, visible);
286 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
290 static void gfio_ui_setup_log(struct gui *ui)
292 GtkTreeSelection *selection;
294 GtkWidget *tree_view;
296 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
298 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
299 gtk_widget_set_can_focus(tree_view, FALSE);
301 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
302 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
303 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
304 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
306 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
307 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
308 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
309 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
311 ui->log_model = model;
312 ui->log_tree = tree_view;
315 static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
321 GType types[FIO_IO_U_LIST_MAX_LEN];
322 GtkWidget *tree_view;
323 GtkTreeSelection *selection;
328 for (i = 0; i < len; i++)
329 types[i] = G_TYPE_INT;
331 model = gtk_list_store_newv(len, types);
333 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
334 gtk_widget_set_can_focus(tree_view, FALSE);
336 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
337 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
339 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
340 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
342 for (i = 0; i < len; i++) {
345 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
346 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
349 gtk_list_store_append(model, &iter);
351 for (i = 0; i < len; i++) {
353 ovals[i] = (ovals[i] + 999) / 1000;
354 gtk_list_store_set(model, &iter, i, ovals[i], -1);
360 static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
363 unsigned int *io_u_plat = ts->io_u_plat[ddir];
364 unsigned long nr = ts->clat_stat[ddir].samples;
365 fio_fp64_t *plist = ts->percentile_list;
366 unsigned int *ovals, len, minv, maxv, scale_down;
368 GtkWidget *tree_view, *frame, *hbox;
371 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
376 * We default to usecs, but if the value range is such that we
377 * should scale down to msecs, do that.
379 if (minv > 2000 && maxv > 99999) {
387 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
389 sprintf(tmp, "Completion percentiles (%s)", base);
390 frame = gtk_frame_new(tmp);
391 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
393 hbox = gtk_hbox_new(FALSE, 3);
394 gtk_container_add(GTK_CONTAINER(frame), hbox);
396 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
402 static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
403 unsigned long max, double mean, double dev)
405 const char *base = "(usec)";
406 GtkWidget *hbox, *label, *frame;
410 if (!usec_to_msec(&min, &max, &mean, &dev))
413 minp = num2str(min, 6, 1, 0);
414 maxp = num2str(max, 6, 1, 0);
416 sprintf(tmp, "%s %s", name, base);
417 frame = gtk_frame_new(tmp);
418 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
420 hbox = gtk_hbox_new(FALSE, 3);
421 gtk_container_add(GTK_CONTAINER(frame), hbox);
423 label = new_info_label_in_frame(hbox, "Minimum");
424 gtk_label_set_text(GTK_LABEL(label), minp);
425 label = new_info_label_in_frame(hbox, "Maximum");
426 gtk_label_set_text(GTK_LABEL(label), maxp);
427 label = new_info_label_in_frame(hbox, "Average");
428 sprintf(tmp, "%5.02f", mean);
429 gtk_label_set_text(GTK_LABEL(label), tmp);
430 label = new_info_label_in_frame(hbox, "Standard deviation");
431 sprintf(tmp, "%5.02f", dev);
432 gtk_label_set_text(GTK_LABEL(label), tmp);
443 static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
444 struct thread_stat *ts, int ddir)
446 const char *ddir_label[2] = { "Read", "Write" };
447 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
448 unsigned long min[3], max[3], runt;
449 unsigned long long bw, iops;
450 unsigned int flags = 0;
451 double mean[3], dev[3];
452 char *io_p, *bw_p, *iops_p;
455 if (!ts->runtime[ddir])
458 i2p = is_power_of_2(rs->kb_base);
459 runt = ts->runtime[ddir];
461 bw = (1000 * ts->io_bytes[ddir]) / runt;
462 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
463 bw_p = num2str(bw, 6, 1, i2p);
465 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
466 iops_p = num2str(iops, 6, 1, 0);
468 box = gtk_hbox_new(FALSE, 3);
469 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
471 frame = gtk_frame_new(ddir_label[ddir]);
472 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
474 main_vbox = gtk_vbox_new(FALSE, 3);
475 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
477 box = gtk_hbox_new(FALSE, 3);
478 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
480 label = new_info_label_in_frame(box, "IO");
481 gtk_label_set_text(GTK_LABEL(label), io_p);
482 label = new_info_label_in_frame(box, "Bandwidth");
483 gtk_label_set_text(GTK_LABEL(label), bw_p);
484 label = new_info_label_in_frame(box, "IOPS");
485 gtk_label_set_text(GTK_LABEL(label), iops_p);
486 label = new_info_label_in_frame(box, "Runtime (msec)");
487 label_set_int_value(label, ts->runtime[ddir]);
489 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
490 double p_of_agg = 100.0;
491 const char *bw_str = "KB";
495 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
496 if (p_of_agg > 100.0)
500 if (mean[0] > 999999.9) {
508 sprintf(tmp, "Bandwidth (%s)", bw_str);
509 frame = gtk_frame_new(tmp);
510 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
512 box = gtk_hbox_new(FALSE, 3);
513 gtk_container_add(GTK_CONTAINER(frame), box);
515 label = new_info_label_in_frame(box, "Minimum");
516 label_set_int_value(label, min[0]);
517 label = new_info_label_in_frame(box, "Maximum");
518 label_set_int_value(label, max[0]);
519 label = new_info_label_in_frame(box, "Percentage of jobs");
520 sprintf(tmp, "%3.2f%%", p_of_agg);
521 gtk_label_set_text(GTK_LABEL(label), tmp);
522 label = new_info_label_in_frame(box, "Average");
523 sprintf(tmp, "%5.02f", mean[0]);
524 gtk_label_set_text(GTK_LABEL(label), tmp);
525 label = new_info_label_in_frame(box, "Standard deviation");
526 sprintf(tmp, "%5.02f", dev[0]);
527 gtk_label_set_text(GTK_LABEL(label), tmp);
530 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
532 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
534 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
538 frame = gtk_frame_new("Latency");
539 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
541 vbox = gtk_vbox_new(FALSE, 3);
542 gtk_container_add(GTK_CONTAINER(frame), vbox);
544 if (flags & GFIO_SLAT)
545 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
546 if (flags & GFIO_CLAT)
547 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
548 if (flags & GFIO_LAT)
549 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
552 if (ts->clat_percentiles)
553 gfio_show_clat_percentiles(main_vbox, ts, ddir);
561 static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
564 GtkWidget *tree_view;
565 GtkTreeSelection *selection;
572 * Check if all are empty, in which case don't bother
574 for (i = 0, skipped = 0; i < num; i++)
581 types = malloc(num * sizeof(GType));
583 for (i = 0; i < num; i++)
584 types[i] = G_TYPE_STRING;
586 model = gtk_list_store_newv(num, types);
590 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
591 gtk_widget_set_can_focus(tree_view, FALSE);
593 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
594 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
596 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
597 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
599 for (i = 0; i < num; i++)
600 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
602 gtk_list_store_append(model, &iter);
604 for (i = 0; i < num; i++) {
608 sprintf(fbuf, "0.00");
610 sprintf(fbuf, "%3.2f%%", lat[i]);
612 gtk_list_store_set(model, &iter, i, fbuf, -1);
618 static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
620 GtkWidget *box, *frame, *tree_view;
621 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
622 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
623 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
624 "250", "500", "750", "1000", };
625 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
626 "250", "500", "750", "1000", "2000",
629 stat_calc_lat_u(ts, io_u_lat_u);
630 stat_calc_lat_m(ts, io_u_lat_m);
632 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
634 frame = gtk_frame_new("Latency buckets (usec)");
635 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
637 box = gtk_hbox_new(FALSE, 3);
638 gtk_container_add(GTK_CONTAINER(frame), box);
639 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
642 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
644 frame = gtk_frame_new("Latency buckets (msec)");
645 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
647 box = gtk_hbox_new(FALSE, 3);
648 gtk_container_add(GTK_CONTAINER(frame), box);
649 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
653 static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
655 GtkWidget *box, *frame, *entry;
656 double usr_cpu, sys_cpu;
657 unsigned long runtime;
660 runtime = ts->total_run_time;
662 double runt = (double) runtime;
664 usr_cpu = (double) ts->usr_time * 100 / runt;
665 sys_cpu = (double) ts->sys_time * 100 / runt;
671 frame = gtk_frame_new("OS resources");
672 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
674 box = gtk_hbox_new(FALSE, 3);
675 gtk_container_add(GTK_CONTAINER(frame), box);
677 entry = new_info_entry_in_frame(box, "User CPU");
678 sprintf(tmp, "%3.2f%%", usr_cpu);
679 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
680 entry = new_info_entry_in_frame(box, "System CPU");
681 sprintf(tmp, "%3.2f%%", sys_cpu);
682 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
683 entry = new_info_entry_in_frame(box, "Context switches");
684 entry_set_int_value(entry, ts->ctx);
685 entry = new_info_entry_in_frame(box, "Major faults");
686 entry_set_int_value(entry, ts->majf);
687 entry = new_info_entry_in_frame(box, "Minor faults");
688 entry_set_int_value(entry, ts->minf);
690 static void gfio_add_sc_depths_tree(GtkListStore *model,
691 struct thread_stat *ts, unsigned int len,
694 double io_u_dist[FIO_IO_U_MAP_NR];
696 /* Bits 0, and 3-8 */
697 const int add_mask = 0x1f9;
701 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
703 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
705 gtk_list_store_append(model, &iter);
707 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
709 for (i = 1, j = 0; i < len; i++) {
712 if (!(add_mask & (1UL << (i - 1))))
713 sprintf(fbuf, "0.0%%");
715 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
719 gtk_list_store_set(model, &iter, i, fbuf, -1);
724 static void gfio_add_total_depths_tree(GtkListStore *model,
725 struct thread_stat *ts, unsigned int len)
727 double io_u_dist[FIO_IO_U_MAP_NR];
729 /* Bits 1-6, and 8 */
730 const int add_mask = 0x17e;
733 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
735 gtk_list_store_append(model, &iter);
737 gtk_list_store_set(model, &iter, 0, "Total", -1);
739 for (i = 1, j = 0; i < len; i++) {
742 if (!(add_mask & (1UL << (i - 1))))
743 sprintf(fbuf, "0.0%%");
745 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
749 gtk_list_store_set(model, &iter, i, fbuf, -1);
754 static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
756 GtkWidget *frame, *box, *tree_view;
757 GtkTreeSelection *selection;
759 GType types[FIO_IO_U_MAP_NR + 1];
762 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
764 frame = gtk_frame_new("IO depths");
765 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
767 box = gtk_hbox_new(FALSE, 3);
768 gtk_container_add(GTK_CONTAINER(frame), box);
770 for (i = 0; i < NR_LABELS; i++)
771 types[i] = G_TYPE_STRING;
773 model = gtk_list_store_newv(NR_LABELS, types);
775 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
776 gtk_widget_set_can_focus(tree_view, FALSE);
778 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
779 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
781 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
782 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
784 for (i = 0; i < NR_LABELS; i++)
785 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
787 gfio_add_total_depths_tree(model, ts, NR_LABELS);
788 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
789 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
791 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
794 static gboolean results_window_delete(GtkWidget *w, gpointer data)
796 struct gui *ui = (struct gui *) data;
798 gtk_widget_destroy(w);
799 ui->results_window = NULL;
800 ui->results_notebook = NULL;
804 static GtkWidget *get_results_window(struct gui *ui)
806 GtkWidget *win, *notebook;
808 if (ui->results_window)
809 return ui->results_notebook;
811 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
812 gtk_window_set_title(GTK_WINDOW(win), "Results");
813 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ui);
814 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ui);
816 notebook = gtk_notebook_new();
817 gtk_container_add(GTK_CONTAINER(win), notebook);
819 ui->results_window = win;
820 ui->results_notebook = notebook;
821 return ui->results_notebook;
824 static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
825 struct group_run_stats *rs)
827 GtkWidget *res_win, *box, *vbox, *entry;
828 struct gfio_client *gc = client->client_data;
832 res_win = get_results_window(gc->ui);
834 vbox = gtk_vbox_new(FALSE, 3);
836 box = gtk_hbox_new(TRUE, 3);
837 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
839 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), vbox, gtk_label_new(ts->name));
841 gc->results_widget = vbox;
843 entry = new_info_entry_in_frame(box, "Name");
844 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
845 if (strlen(ts->description)) {
846 entry = new_info_entry_in_frame(box, "Description");
847 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
849 entry = new_info_entry_in_frame(box, "Group ID");
850 entry_set_int_value(entry, ts->groupid);
851 entry = new_info_entry_in_frame(box, "Jobs");
852 entry_set_int_value(entry, ts->members);
853 entry = new_info_entry_in_frame(box, "Error");
854 entry_set_int_value(entry, ts->error);
855 entry = new_info_entry_in_frame(box, "PID");
856 entry_set_int_value(entry, ts->pid);
858 if (ts->io_bytes[DDIR_READ])
859 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
860 if (ts->io_bytes[DDIR_WRITE])
861 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
863 gfio_show_latency_buckets(vbox, ts);
864 gfio_show_cpu_usage(vbox, ts);
865 gfio_show_io_depths(vbox, ts);
867 gtk_widget_show_all(gc->ui->results_window);
871 static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
873 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
874 struct gfio_client *gc = client->client_data;
878 char tmp[64], timebuf[80];
881 tm = localtime(&sec);
882 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
883 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
887 gtk_list_store_append(gc->ui->log_model, &iter);
888 gtk_list_store_set(gc->ui->log_model, &iter, 0, timebuf, -1);
889 gtk_list_store_set(gc->ui->log_model, &iter, 1, client->hostname, -1);
890 gtk_list_store_set(gc->ui->log_model, &iter, 2, p->level, -1);
891 gtk_list_store_set(gc->ui->log_model, &iter, 3, p->buf, -1);
896 static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
898 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
899 struct gfio_client *gc = client->client_data;
900 GtkWidget *box, *frame, *entry, *vbox;
904 if (!gc->results_widget)
907 if (!gc->disk_util_frame) {
908 gc->disk_util_frame = gtk_frame_new("Disk utilization");
909 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
912 vbox = gtk_vbox_new(FALSE, 3);
913 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
915 frame = gtk_frame_new((char *) p->dus.name);
916 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
918 box = gtk_vbox_new(FALSE, 3);
919 gtk_container_add(GTK_CONTAINER(frame), box);
921 frame = gtk_frame_new("Read");
922 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
923 vbox = gtk_hbox_new(TRUE, 3);
924 gtk_container_add(GTK_CONTAINER(frame), vbox);
925 entry = new_info_entry_in_frame(vbox, "IOs");
926 entry_set_int_value(entry, p->dus.ios[0]);
927 entry = new_info_entry_in_frame(vbox, "Merges");
928 entry_set_int_value(entry, p->dus.merges[0]);
929 entry = new_info_entry_in_frame(vbox, "Sectors");
930 entry_set_int_value(entry, p->dus.sectors[0]);
931 entry = new_info_entry_in_frame(vbox, "Ticks");
932 entry_set_int_value(entry, p->dus.ticks[0]);
934 frame = gtk_frame_new("Write");
935 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
936 vbox = gtk_hbox_new(TRUE, 3);
937 gtk_container_add(GTK_CONTAINER(frame), vbox);
938 entry = new_info_entry_in_frame(vbox, "IOs");
939 entry_set_int_value(entry, p->dus.ios[1]);
940 entry = new_info_entry_in_frame(vbox, "Merges");
941 entry_set_int_value(entry, p->dus.merges[1]);
942 entry = new_info_entry_in_frame(vbox, "Sectors");
943 entry_set_int_value(entry, p->dus.sectors[1]);
944 entry = new_info_entry_in_frame(vbox, "Ticks");
945 entry_set_int_value(entry, p->dus.ticks[1]);
947 frame = gtk_frame_new("Shared");
948 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
949 vbox = gtk_hbox_new(TRUE, 3);
950 gtk_container_add(GTK_CONTAINER(frame), vbox);
951 entry = new_info_entry_in_frame(vbox, "IO ticks");
952 entry_set_int_value(entry, p->dus.io_ticks);
953 entry = new_info_entry_in_frame(vbox, "Time in queue");
954 entry_set_int_value(entry, p->dus.time_in_queue);
956 gtk_widget_show_all(gc->results_widget);
961 extern int sum_stat_clients;
962 extern struct thread_stat client_ts;
963 extern struct group_run_stats client_gs;
965 static int sum_stat_nr;
967 static void gfio_thread_status_op(struct fio_client *client,
968 struct fio_net_cmd *cmd)
970 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
972 gfio_display_ts(client, &p->ts, &p->rs);
974 if (sum_stat_clients == 1)
977 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
978 sum_group_stats(&client_gs, &p->rs);
981 client_ts.groupid = p->ts.groupid;
983 if (++sum_stat_nr == sum_stat_clients) {
984 strcpy(client_ts.name, "All clients");
985 gfio_display_ts(client, &client_ts, &client_gs);
989 static void gfio_group_stats_op(struct fio_client *client,
990 struct fio_net_cmd *cmd)
993 printf("gfio_group_stats_op called\n");
994 fio_client_ops.group_stats(client, cmd);
998 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1000 struct gui *ui = (struct gui *) p;
1003 cr = gdk_cairo_create(w->window);
1005 cairo_set_source_rgb(cr, 0, 0, 0);
1008 cairo_translate(cr, 0, 0);
1009 line_graph_draw(ui->bandwidth_graph, cr);
1014 cairo_translate(cr, DRAWING_AREA_XDIM / 2.0, 0);
1015 // DRAWING_AREA_YDIM * 0.05);
1016 line_graph_draw(ui->iops_graph, cr);
1024 static void gfio_update_eta(struct jobs_eta *je)
1026 static int eta_good;
1033 gdk_threads_enter();
1038 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1039 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1040 eta_to_str(eta_str, je->eta_sec);
1043 sprintf(tmp, "%u", je->nr_running);
1044 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
1045 sprintf(tmp, "%u", je->files_open);
1046 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
1049 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1050 if (je->m_rate || je->t_rate) {
1053 mr = num2str(je->m_rate, 4, 0, i2p);
1054 tr = num2str(je->t_rate, 4, 0, i2p);
1055 gtk_entry_set_text(GTK_ENTRY(ui.eta);
1056 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1059 } else if (je->m_iops || je->t_iops)
1060 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1062 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
1063 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
1064 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
1065 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
1068 if (je->eta_sec != INT_MAX && je->nr_running) {
1072 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1073 strcpy(output, "-.-% done");
1077 sprintf(output, "%3.1f%% done", perc);
1080 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1081 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1083 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1084 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1086 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
1087 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
1088 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
1089 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
1091 graph_add_xy_data(ui.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
1092 graph_add_xy_data(ui.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
1093 graph_add_xy_data(ui.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
1094 graph_add_xy_data(ui.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
1103 char *dst = output + strlen(output);
1105 sprintf(dst, " - %s", eta_str);
1108 gfio_update_thread_status(output, perc);
1109 gdk_threads_leave();
1112 static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1114 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
1115 struct gfio_client *gc = client->client_data;
1116 struct gui *ui = gc->ui;
1117 const char *os, *arch;
1120 os = fio_get_os_string(probe->os);
1124 arch = fio_get_arch_string(probe->arch);
1129 client->name = strdup((char *) probe->hostname);
1131 gdk_threads_enter();
1133 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), (char *) probe->hostname);
1134 gtk_label_set_text(GTK_LABEL(ui->probe.os), os);
1135 gtk_label_set_text(GTK_LABEL(ui->probe.arch), arch);
1136 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
1137 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), buf);
1139 gfio_set_connected(ui, 1);
1141 gdk_threads_leave();
1144 static void gfio_update_thread_status(char *status_message, double perc)
1146 static char message[100];
1147 const char *m = message;
1149 strncpy(message, status_message, sizeof(message) - 1);
1150 gtk_progress_bar_set_text(
1151 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
1152 gtk_progress_bar_set_fraction(
1153 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
1154 gtk_widget_queue_draw(ui.window);
1157 static void gfio_quit_op(struct fio_client *client)
1159 struct gfio_client *gc = client->client_data;
1161 gdk_threads_enter();
1162 gfio_set_connected(gc->ui, 0);
1163 gdk_threads_leave();
1166 static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1168 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
1169 struct gfio_client *gc = client->client_data;
1170 struct gui *ui = gc->ui;
1174 p->iodepth = le32_to_cpu(p->iodepth);
1175 p->rw = le32_to_cpu(p->rw);
1177 for (i = 0; i < 2; i++) {
1178 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
1179 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
1182 p->numjobs = le32_to_cpu(p->numjobs);
1183 p->group_reporting = le32_to_cpu(p->group_reporting);
1185 gdk_threads_enter();
1187 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
1188 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
1189 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
1191 sprintf(tmp, "%u", p->iodepth);
1192 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
1194 gdk_threads_leave();
1197 static void gfio_client_timed_out(struct fio_client *client)
1199 struct gfio_client *gc = client->client_data;
1200 GtkWidget *dialog, *label, *content;
1203 gdk_threads_enter();
1205 gfio_set_connected(gc->ui, 0);
1206 clear_ui_info(gc->ui);
1208 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1210 dialog = gtk_dialog_new_with_buttons("Timed out!",
1211 GTK_WINDOW(gc->ui->window),
1212 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1213 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
1215 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1216 label = gtk_label_new((const gchar *) buf);
1217 gtk_container_add(GTK_CONTAINER(content), label);
1218 gtk_widget_show_all(dialog);
1219 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1221 gtk_dialog_run(GTK_DIALOG(dialog));
1222 gtk_widget_destroy(dialog);
1224 gdk_threads_leave();
1227 struct client_ops gfio_client_ops = {
1228 .text_op = gfio_text_op,
1229 .disk_util = gfio_disk_util_op,
1230 .thread_status = gfio_thread_status_op,
1231 .group_stats = gfio_group_stats_op,
1232 .eta = gfio_update_eta,
1233 .probe = gfio_probe_op,
1234 .quit = gfio_quit_op,
1235 .add_job = gfio_add_job_op,
1236 .timed_out = gfio_client_timed_out,
1237 .stay_connected = 1,
1240 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1241 __attribute__((unused)) gpointer data)
1246 static void *job_thread(void *arg)
1248 fio_handle_clients(&gfio_client_ops);
1252 static int send_job_files(struct gui *ui)
1256 for (i = 0; i < ui->nr_job_files; i++) {
1257 ret = fio_clients_send_ini(ui->job_files[i]);
1261 free(ui->job_files[i]);
1262 ui->job_files[i] = NULL;
1264 while (i < ui->nr_job_files) {
1265 free(ui->job_files[i]);
1266 ui->job_files[i] = NULL;
1273 static void start_job_thread(struct gui *ui)
1275 if (send_job_files(ui)) {
1276 printf("Yeah, I didn't really like those options too much.\n");
1277 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
1282 static void *server_thread(void *arg)
1285 gfio_server_running = 1;
1286 fio_start_server(NULL);
1287 gfio_server_running = 0;
1291 static void gfio_start_server(struct gui *ui)
1293 if (!gfio_server_running) {
1294 gfio_server_running = 1;
1295 pthread_create(&ui->server_t, NULL, server_thread, NULL);
1296 pthread_detach(ui->server_t);
1300 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
1303 struct gui *ui = data;
1305 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
1306 start_job_thread(ui);
1309 static void file_open(GtkWidget *w, gpointer data);
1311 static void connect_clicked(GtkWidget *widget, gpointer data)
1313 struct gui *ui = data;
1315 if (!ui->connected) {
1316 if (!ui->nr_job_files)
1317 file_open(widget, data);
1318 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
1319 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1320 if (!fio_clients_connect()) {
1321 pthread_create(&ui->t, NULL, job_thread, NULL);
1322 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 0);
1325 fio_clients_terminate();
1326 gfio_set_connected(ui, 0);
1331 static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
1332 struct button_spec *buttonspec)
1334 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
1335 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
1336 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
1337 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
1338 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
1341 static void add_buttons(struct gui *ui,
1342 struct button_spec *buttonlist,
1347 for (i = 0; i < nbuttons; i++)
1348 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
1351 static void on_info_bar_response(GtkWidget *widget, gint response,
1354 if (response == GTK_RESPONSE_OK) {
1355 gtk_widget_destroy(widget);
1356 ui.error_info_bar = NULL;
1360 void report_error(GError *error)
1362 if (ui.error_info_bar == NULL) {
1363 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1366 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1367 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
1370 ui.error_label = gtk_label_new(error->message);
1371 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
1372 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
1374 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
1375 gtk_widget_show_all(ui.vbox);
1378 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1379 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
1383 struct connection_widgets
1390 static void hostname_cb(GtkEntry *entry, gpointer data)
1392 struct connection_widgets *cw = data;
1393 int uses_net = 0, is_localhost = 0;
1398 * Check whether to display the 'auto start backend' box
1399 * or not. Show it if we are a localhost and using network,
1400 * or using a socket.
1402 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1403 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1408 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1409 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1410 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1411 !strcmp(text, "ip6-loopback"))
1415 if (!uses_net || is_localhost) {
1416 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1417 gtk_widget_set_sensitive(cw->button, 1);
1419 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1420 gtk_widget_set_sensitive(cw->button, 0);
1424 static int get_connection_details(char **host, int *port, int *type,
1427 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1428 struct connection_widgets cw;
1431 dialog = gtk_dialog_new_with_buttons("Connection details",
1432 GTK_WINDOW(ui.window),
1433 GTK_DIALOG_DESTROY_WITH_PARENT,
1434 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1435 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1437 frame = gtk_frame_new("Hostname / socket name");
1438 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1439 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1441 box = gtk_vbox_new(FALSE, 6);
1442 gtk_container_add(GTK_CONTAINER(frame), box);
1444 hbox = gtk_hbox_new(TRUE, 10);
1445 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1446 cw.hentry = gtk_entry_new();
1447 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
1448 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
1450 frame = gtk_frame_new("Port");
1451 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1452 box = gtk_vbox_new(FALSE, 10);
1453 gtk_container_add(GTK_CONTAINER(frame), box);
1455 hbox = gtk_hbox_new(TRUE, 4);
1456 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1457 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1459 frame = gtk_frame_new("Type");
1460 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1461 box = gtk_vbox_new(FALSE, 10);
1462 gtk_container_add(GTK_CONTAINER(frame), box);
1464 hbox = gtk_hbox_new(TRUE, 4);
1465 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1467 cw.combo = gtk_combo_box_new_text();
1468 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
1469 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
1470 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
1471 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
1473 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
1475 frame = gtk_frame_new("Options");
1476 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1477 box = gtk_vbox_new(FALSE, 10);
1478 gtk_container_add(GTK_CONTAINER(frame), box);
1480 hbox = gtk_hbox_new(TRUE, 4);
1481 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1483 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1484 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
1485 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.");
1486 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
1489 * Connect edit signal, so we can show/not-show the auto start button
1491 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
1492 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
1494 gtk_widget_show_all(dialog);
1496 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1497 gtk_widget_destroy(dialog);
1501 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
1502 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1504 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
1505 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1506 *type = Fio_client_ipv4;
1507 else if (!strncmp(typeentry, "IPv6", 4))
1508 *type = Fio_client_ipv6;
1510 *type = Fio_client_socket;
1513 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
1515 gtk_widget_destroy(dialog);
1519 static void gfio_client_added(struct gui *ui, struct fio_client *client)
1521 struct gfio_client *gc;
1523 gc = malloc(sizeof(*gc));
1524 memset(gc, 0, sizeof(*gc));
1527 client->client_data = gc;
1530 static void file_open(GtkWidget *w, gpointer data)
1533 struct gui *ui = data;
1534 GSList *filenames, *fn_glist;
1535 GtkFileFilter *filter;
1537 int port, type, server_start;
1539 dialog = gtk_file_chooser_dialog_new("Open File",
1540 GTK_WINDOW(ui->window),
1541 GTK_FILE_CHOOSER_ACTION_OPEN,
1542 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1543 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1545 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1547 filter = gtk_file_filter_new();
1548 gtk_file_filter_add_pattern(filter, "*.fio");
1549 gtk_file_filter_add_pattern(filter, "*.job");
1550 gtk_file_filter_add_pattern(filter, "*.ini");
1551 gtk_file_filter_add_mime_type(filter, "text/fio");
1552 gtk_file_filter_set_name(filter, "Fio job file");
1553 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1555 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1556 gtk_widget_destroy(dialog);
1560 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
1562 gtk_widget_destroy(dialog);
1564 if (get_connection_details(&host, &port, &type, &server_start))
1567 filenames = fn_glist;
1568 while (filenames != NULL) {
1569 struct fio_client *client;
1571 ui->job_files = realloc(ui->job_files, (ui->nr_job_files + 1) * sizeof(char *));
1572 ui->job_files[ui->nr_job_files] = strdup(filenames->data);
1575 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
1579 error = g_error_new(g_quark_from_string("fio"), 1,
1580 "Failed to add client %s", host);
1581 report_error(error);
1582 g_error_free(error);
1584 gfio_client_added(ui, client);
1586 g_free(filenames->data);
1587 filenames = g_slist_next(filenames);
1592 gfio_start_server(ui);
1594 g_slist_free(fn_glist);
1597 static void file_save(GtkWidget *w, gpointer data)
1599 struct gui *ui = data;
1602 dialog = gtk_file_chooser_dialog_new("Save File",
1603 GTK_WINDOW(ui->window),
1604 GTK_FILE_CHOOSER_ACTION_SAVE,
1605 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1606 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1609 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1610 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1612 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1615 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1616 // save_job_file(filename);
1619 gtk_widget_destroy(dialog);
1622 static void view_log_destroy(GtkWidget *w, gpointer data)
1624 struct gui *ui = (struct gui *) data;
1626 gtk_widget_ref(ui->log_tree);
1627 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
1628 gtk_widget_destroy(w);
1629 ui->log_view = NULL;
1632 static void view_log(GtkWidget *w, gpointer data)
1634 GtkWidget *win, *scroll, *vbox, *box;
1635 struct gui *ui = (struct gui *) data;
1640 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1641 gtk_window_set_title(GTK_WINDOW(win), "Log");
1642 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
1644 scroll = gtk_scrolled_window_new(NULL, NULL);
1646 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1648 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1650 box = gtk_hbox_new(TRUE, 0);
1651 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
1652 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
1653 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
1655 vbox = gtk_vbox_new(TRUE, 5);
1656 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
1658 gtk_container_add(GTK_CONTAINER(win), vbox);
1659 gtk_widget_show_all(win);
1662 static void preferences(GtkWidget *w, gpointer data)
1664 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
1667 dialog = gtk_dialog_new_with_buttons("Preferences",
1668 GTK_WINDOW(ui.window),
1669 GTK_DIALOG_DESTROY_WITH_PARENT,
1670 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1671 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1674 frame = gtk_frame_new("Debug logging");
1675 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1677 vbox = gtk_vbox_new(FALSE, 6);
1678 gtk_container_add(GTK_CONTAINER(frame), vbox);
1680 box = gtk_hbox_new(FALSE, 6);
1681 gtk_container_add(GTK_CONTAINER(vbox), box);
1683 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1685 for (i = 0; i < FD_DEBUG_MAX; i++) {
1687 box = gtk_hbox_new(FALSE, 6);
1688 gtk_container_add(GTK_CONTAINER(vbox), box);
1692 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
1693 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
1694 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1697 frame = gtk_frame_new("Graph font");
1698 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1699 vbox = gtk_vbox_new(FALSE, 6);
1700 gtk_container_add(GTK_CONTAINER(frame), vbox);
1702 font = gtk_font_button_new();
1703 gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5);
1705 gtk_widget_show_all(dialog);
1707 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1708 gtk_widget_destroy(dialog);
1712 for (i = 0; i < FD_DEBUG_MAX; i++) {
1715 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1717 fio_debug |= (1UL << i);
1720 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
1721 gtk_widget_destroy(dialog);
1724 static void about_dialog(GtkWidget *w, gpointer data)
1726 const char *authors[] = {
1727 "Jens Axboe <axboe@kernel.dk>",
1728 "Stephen Carmeron <stephenmcameron@gmail.com>",
1731 const char *license[] = {
1732 "Fio is free software; you can redistribute it and/or modify "
1733 "it under the terms of the GNU General Public License as published by "
1734 "the Free Software Foundation; either version 2 of the License, or "
1735 "(at your option) any later version.\n",
1736 "Fio is distributed in the hope that it will be useful, "
1737 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
1738 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
1739 "GNU General Public License for more details.\n",
1740 "You should have received a copy of the GNU General Public License "
1741 "along with Fio; if not, write to the Free Software Foundation, Inc., "
1742 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
1744 char *license_trans;
1746 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
1747 license[2], "\n", NULL);
1749 gtk_show_about_dialog(NULL,
1750 "program-name", "gfio",
1751 "comments", "Gtk2 UI for fio",
1752 "license", license_trans,
1753 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
1755 "version", fio_version_string,
1756 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
1757 "logo-icon-name", "fio",
1759 "wrap-license", TRUE,
1762 g_free (license_trans);
1765 static GtkActionEntry menu_items[] = {
1766 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1767 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
1768 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1769 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1770 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1771 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1772 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
1773 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1774 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
1776 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
1778 static const gchar *ui_string = " \
1780 <menubar name=\"MainMenu\"> \
1781 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1782 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1783 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1784 <separator name=\"Separator\"/> \
1785 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1786 <separator name=\"Separator2\"/> \
1787 <menuitem name=\"Quit\" action=\"Quit\" /> \
1789 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
1790 <menuitem name=\"Log\" action=\"ViewLog\" /> \
1792 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1793 <menuitem name=\"About\" action=\"About\" /> \
1799 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
1802 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1805 action_group = gtk_action_group_new("Menu");
1806 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
1808 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1809 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1811 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1812 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1815 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1816 GtkWidget *vbox, GtkUIManager *ui_manager)
1818 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1821 static void init_ui(int *argc, char **argv[], struct gui *ui)
1823 GtkSettings *settings;
1824 GtkUIManager *uimanager;
1825 GtkWidget *menu, *probe, *probe_frame, *probe_box;
1828 memset(ui, 0, sizeof(*ui));
1830 /* Magical g*thread incantation, you just need this thread stuff.
1831 * Without it, the update that happens in gfio_update_thread_status
1832 * doesn't really happen in a timely fashion, you need expose events
1834 if (!g_thread_supported())
1835 g_thread_init(NULL);
1838 gtk_init(argc, argv);
1839 settings = gtk_settings_get_default();
1840 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1843 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1844 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1845 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 700);
1847 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1848 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
1850 ui->vbox = gtk_vbox_new(FALSE, 0);
1851 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
1853 uimanager = gtk_ui_manager_new();
1854 menu = get_menubar_menu(ui->window, uimanager, ui);
1855 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1858 * Set up alignments for widgets at the top of ui,
1859 * align top left, expand horizontally but not vertically
1861 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
1862 ui->topvbox = gtk_vbox_new(FALSE, 3);
1863 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
1864 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
1866 probe = gtk_frame_new("Job");
1867 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1868 probe_frame = gtk_vbox_new(FALSE, 3);
1869 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1871 probe_box = gtk_hbox_new(FALSE, 3);
1872 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1873 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1874 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1875 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1876 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1878 probe_box = gtk_hbox_new(FALSE, 3);
1879 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1881 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1882 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1883 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1884 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1885 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1886 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
1888 probe_box = gtk_hbox_new(FALSE, 3);
1889 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1890 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1891 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1892 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1893 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
1896 * Only add this if we have a commit rate
1899 probe_box = gtk_hbox_new(FALSE, 3);
1900 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1902 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1903 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1905 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1906 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1910 * Set up a drawing area and IOPS and bandwidth graphs
1912 gdk_color_parse("white", &white);
1913 ui->drawing_area = gtk_drawing_area_new();
1914 gtk_widget_set_size_request(GTK_WIDGET(ui->drawing_area),
1915 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
1916 gtk_widget_modify_bg(ui->drawing_area, GTK_STATE_NORMAL, &white);
1917 g_signal_connect(G_OBJECT(ui->drawing_area), "expose_event",
1918 G_CALLBACK (on_expose_drawing_area), ui);
1919 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1920 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1921 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1922 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1924 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1927 setup_iops_graph(ui);
1928 setup_bandwidth_graph(ui);
1931 * Set up alignments for widgets at the bottom of ui,
1932 * align bottom left, expand horizontally but not vertically
1934 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1935 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1936 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
1937 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1940 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
1943 * Set up thread status progress bar
1945 ui->thread_status_pb = gtk_progress_bar_new();
1946 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1947 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
1948 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1950 gfio_ui_setup_log(ui);
1952 gtk_widget_show_all(ui->window);
1955 int main(int argc, char *argv[], char *envp[])
1957 if (initialize_fio(envp))
1959 if (fio_init_options())
1962 init_ui(&argc, &argv, &ui);
1964 gdk_threads_enter();
1966 gdk_threads_leave();