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
35 #define GFIO_MIME "text/fio"
37 static int gfio_server_running;
38 static const char *gfio_graph_font;
39 static unsigned int gfio_graph_limit = 100;
41 static void view_log(GtkWidget *w, gpointer data);
43 #define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
45 typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
47 static void connect_clicked(GtkWidget *widget, gpointer data);
48 static void start_job_clicked(GtkWidget *widget, gpointer data);
49 static void send_clicked(GtkWidget *widget, gpointer data);
51 static struct button_spec {
52 const char *buttontext;
54 const char *tooltiptext;
55 const int start_insensitive;
56 } buttonspeclist[] = {
57 #define CONNECT_BUTTON 0
59 #define START_JOB_BUTTON 2
60 { "Connect", connect_clicked, "Connect to host", 0 },
61 { "Send", send_clicked, "Send job description to host", 1 },
62 { "Start Job", start_job_clicked,
63 "Start the current job on the server", 1 },
73 struct multitext_widget {
76 unsigned int cur_text;
77 unsigned int max_text;
82 struct multitext_widget iotype;
83 struct multitext_widget ioengine;
84 struct multitext_widget iodepth;
92 GtkWidget *write_iops;
98 #define DRAWING_AREA_XDIM 1000
99 #define DRAWING_AREA_YDIM 400
100 GtkWidget *drawing_area;
101 struct graph *iops_graph;
102 struct graph *bandwidth_graph;
106 * Main window widgets and data
109 GtkUIManager *uimanager;
110 GtkRecentManager *recentmanager;
111 GtkActionGroup *actiongroup;
116 GtkWidget *thread_status_pb;
117 GtkWidget *buttonbox;
119 GtkWidget *error_info_bar;
120 GtkWidget *error_label;
121 GtkListStore *log_model;
124 struct gfio_graphs graphs;
125 struct probe_widget probe;
126 struct eta_widget eta;
132 struct flist_head list;
139 GE_STATE_JOB_STARTED,
140 GE_STATE_JOB_RUNNING,
148 struct flist_head list;
152 GtkWidget *job_notebook;
153 GtkWidget *thread_status_pb;
154 GtkWidget *buttonbox;
155 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
157 GtkWidget *error_info_bar;
158 GtkWidget *error_label;
159 GtkWidget *results_notebook;
160 GtkWidget *results_window;
161 GtkListStore *log_model;
164 struct gfio_graphs graphs;
165 struct probe_widget probe;
166 struct eta_widget eta;
167 GtkWidget *page_label;
171 struct gfio_client *client;
177 struct gui_entry *ge;
178 struct fio_client *client;
179 GtkWidget *results_widget;
180 GtkWidget *disk_util_frame;
181 GtkWidget *err_entry;
182 unsigned int job_added;
183 struct thread_options o;
186 static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
187 static void gfio_update_thread_status_all(char *status_message, double perc);
188 void report_error(GError *error);
190 static struct graph *setup_iops_graph(void)
194 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
195 graph_title(g, "IOPS (IOs/sec)");
196 graph_x_title(g, "Time (secs)");
197 graph_add_label(g, "Read IOPS");
198 graph_add_label(g, "Write IOPS");
199 graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
200 graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
201 line_graph_set_data_count_limit(g, gfio_graph_limit);
202 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
206 static struct graph *setup_bandwidth_graph(void)
210 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
211 graph_title(g, "Bandwidth (bytes/sec)");
212 graph_x_title(g, "Time (secs)");
213 graph_add_label(g, "Read Bandwidth");
214 graph_add_label(g, "Write Bandwidth");
215 graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
216 graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
217 graph_set_base_offset(g, 1);
218 line_graph_set_data_count_limit(g, 100);
219 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
223 static void setup_graphs(struct gfio_graphs *g)
225 g->iops_graph = setup_iops_graph();
226 g->bandwidth_graph = setup_bandwidth_graph();
229 static void multitext_add_entry(struct multitext_widget *mt, const char *text)
231 mt->text = realloc(mt->text, (mt->max_text + 1) * sizeof(char *));
232 mt->text[mt->max_text] = strdup(text);
236 static void multitext_set_entry(struct multitext_widget *mt, unsigned int index)
238 if (index >= mt->max_text)
240 if (!mt->text || !mt->text[index])
243 mt->cur_text = index;
244 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
247 static void multitext_update_entry(struct multitext_widget *mt,
248 unsigned int index, const char *text)
254 free(mt->text[index]);
256 mt->text[index] = strdup(text);
257 if (mt->cur_text == index)
258 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
261 static void multitext_free(struct multitext_widget *mt)
265 gtk_entry_set_text(GTK_ENTRY(mt->entry), "");
267 for (i = 0; i < mt->max_text; i++) {
277 static void clear_ge_ui_info(struct gui_entry *ge)
279 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
280 gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
281 gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
282 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
284 /* should we empty it... */
285 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
287 multitext_update_entry(&ge->eta.iotype, 0, "");
288 multitext_update_entry(&ge->eta.ioengine, 0, "");
289 multitext_update_entry(&ge->eta.iodepth, 0, "");
290 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
291 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
292 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
293 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
294 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
295 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
298 static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label)
300 GtkWidget *entry, *frame;
302 frame = gtk_frame_new(label);
303 entry = gtk_combo_box_new_text();
304 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
305 gtk_container_add(GTK_CONTAINER(frame), entry);
310 static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
312 GtkWidget *entry, *frame;
314 frame = gtk_frame_new(label);
315 entry = gtk_entry_new();
316 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
317 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
318 gtk_container_add(GTK_CONTAINER(frame), entry);
323 static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
325 GtkWidget *label_widget;
328 frame = gtk_frame_new(label);
329 label_widget = gtk_label_new(NULL);
330 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
331 gtk_container_add(GTK_CONTAINER(frame), label_widget);
336 static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
338 GtkWidget *button, *box;
340 box = gtk_hbox_new(FALSE, 3);
341 gtk_container_add(GTK_CONTAINER(hbox), box);
343 button = gtk_spin_button_new_with_range(min, max, 1.0);
344 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
346 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
347 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
352 static void label_set_int_value(GtkWidget *entry, unsigned int val)
356 sprintf(tmp, "%u", val);
357 gtk_label_set_text(GTK_LABEL(entry), tmp);
360 static void entry_set_int_value(GtkWidget *entry, unsigned int val)
364 sprintf(tmp, "%u", val);
365 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
368 static void show_info_dialog(struct gui *ui, const char *title,
371 GtkWidget *dialog, *content, *label;
373 dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(ui->window),
374 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
375 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
377 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
378 label = gtk_label_new(message);
379 gtk_container_add(GTK_CONTAINER(content), label);
380 gtk_widget_show_all(dialog);
381 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
382 gtk_dialog_run(GTK_DIALOG(dialog));
383 gtk_widget_destroy(dialog);
387 * Update sensitivity of job buttons and job menu items, based on the
388 * state of the client.
390 static void update_button_states(struct gui *ui, struct gui_entry *ge)
392 unsigned int connect_state, send_state, start_state, edit_state;
393 const char *connect_str = NULL;
400 sprintf(tmp, "Bad client state: %u\n", ge->state);
401 show_info_dialog(ui, "Error", tmp);
402 /* fall through to new state */
408 connect_str = "Connect";
412 case GE_STATE_CONNECTED:
415 connect_str = "Disconnect";
419 case GE_STATE_JOB_SENT:
422 connect_str = "Disconnect";
426 case GE_STATE_JOB_STARTED:
429 connect_str = "Disconnect";
433 case GE_STATE_JOB_RUNNING:
436 connect_str = "Disconnect";
440 case GE_STATE_JOB_DONE:
443 connect_str = "Connect";
449 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], connect_state);
450 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], send_state);
451 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], start_state);
452 gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), connect_str);
455 * So the below doesn't work at all, how to set those menu items
458 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Connect");
459 gtk_widget_set_sensitive(w, connect_state);
460 gtk_menu_item_set_label(GTK_MENU_ITEM(w), connect_str);
462 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Edit job");
463 gtk_widget_set_sensitive(w, edit_state);
465 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Send job");
466 gtk_widget_set_sensitive(w, send_state);
468 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Start job");
469 gtk_widget_set_sensitive(w, start_state);
472 static void gfio_set_state(struct gui_entry *ge, unsigned int state)
475 update_button_states(ge->ui, ge);
479 #define ALIGN_RIGHT 2
483 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
485 GtkCellRenderer *renderer;
486 GtkTreeViewColumn *col;
487 double xalign = 0.0; /* left as default */
488 PangoAlignment align;
491 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
492 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
494 visible = !(flags & INVISIBLE);
496 renderer = gtk_cell_renderer_text_new();
497 col = gtk_tree_view_column_new();
499 gtk_tree_view_column_set_title(col, title);
500 if (!(flags & UNSORTABLE))
501 gtk_tree_view_column_set_sort_column_id(col, index);
502 gtk_tree_view_column_set_resizable(col, TRUE);
503 gtk_tree_view_column_pack_start(col, renderer, TRUE);
504 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
505 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
507 case PANGO_ALIGN_LEFT:
510 case PANGO_ALIGN_CENTER:
513 case PANGO_ALIGN_RIGHT:
517 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
518 gtk_tree_view_column_set_visible(col, visible);
519 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
523 static void gfio_ui_setup_log(struct gui *ui)
525 GtkTreeSelection *selection;
527 GtkWidget *tree_view;
529 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
531 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
532 gtk_widget_set_can_focus(tree_view, FALSE);
534 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
535 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
536 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
537 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
539 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
540 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
541 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
542 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
544 ui->log_model = model;
545 ui->log_tree = tree_view;
548 static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
554 GType types[FIO_IO_U_LIST_MAX_LEN];
555 GtkWidget *tree_view;
556 GtkTreeSelection *selection;
561 for (i = 0; i < len; i++)
562 types[i] = G_TYPE_INT;
564 model = gtk_list_store_newv(len, types);
566 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
567 gtk_widget_set_can_focus(tree_view, FALSE);
569 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
570 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
572 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
573 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
575 for (i = 0; i < len; i++) {
578 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
579 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
582 gtk_list_store_append(model, &iter);
584 for (i = 0; i < len; i++) {
586 ovals[i] = (ovals[i] + 999) / 1000;
587 gtk_list_store_set(model, &iter, i, ovals[i], -1);
593 static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
596 unsigned int *io_u_plat = ts->io_u_plat[ddir];
597 unsigned long nr = ts->clat_stat[ddir].samples;
598 fio_fp64_t *plist = ts->percentile_list;
599 unsigned int *ovals, len, minv, maxv, scale_down;
601 GtkWidget *tree_view, *frame, *hbox;
604 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
609 * We default to usecs, but if the value range is such that we
610 * should scale down to msecs, do that.
612 if (minv > 2000 && maxv > 99999) {
620 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
622 sprintf(tmp, "Completion percentiles (%s)", base);
623 frame = gtk_frame_new(tmp);
624 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
626 hbox = gtk_hbox_new(FALSE, 3);
627 gtk_container_add(GTK_CONTAINER(frame), hbox);
629 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
635 static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
636 unsigned long max, double mean, double dev)
638 const char *base = "(usec)";
639 GtkWidget *hbox, *label, *frame;
643 if (!usec_to_msec(&min, &max, &mean, &dev))
646 minp = num2str(min, 6, 1, 0);
647 maxp = num2str(max, 6, 1, 0);
649 sprintf(tmp, "%s %s", name, base);
650 frame = gtk_frame_new(tmp);
651 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
653 hbox = gtk_hbox_new(FALSE, 3);
654 gtk_container_add(GTK_CONTAINER(frame), hbox);
656 label = new_info_label_in_frame(hbox, "Minimum");
657 gtk_label_set_text(GTK_LABEL(label), minp);
658 label = new_info_label_in_frame(hbox, "Maximum");
659 gtk_label_set_text(GTK_LABEL(label), maxp);
660 label = new_info_label_in_frame(hbox, "Average");
661 sprintf(tmp, "%5.02f", mean);
662 gtk_label_set_text(GTK_LABEL(label), tmp);
663 label = new_info_label_in_frame(hbox, "Standard deviation");
664 sprintf(tmp, "%5.02f", dev);
665 gtk_label_set_text(GTK_LABEL(label), tmp);
676 static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
677 struct thread_stat *ts, int ddir)
679 const char *ddir_label[2] = { "Read", "Write" };
680 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
681 unsigned long min[3], max[3], runt;
682 unsigned long long bw, iops;
683 unsigned int flags = 0;
684 double mean[3], dev[3];
685 char *io_p, *bw_p, *iops_p;
688 if (!ts->runtime[ddir])
691 i2p = is_power_of_2(rs->kb_base);
692 runt = ts->runtime[ddir];
694 bw = (1000 * ts->io_bytes[ddir]) / runt;
695 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
696 bw_p = num2str(bw, 6, 1, i2p);
698 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
699 iops_p = num2str(iops, 6, 1, 0);
701 box = gtk_hbox_new(FALSE, 3);
702 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
704 frame = gtk_frame_new(ddir_label[ddir]);
705 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
707 main_vbox = gtk_vbox_new(FALSE, 3);
708 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
710 box = gtk_hbox_new(FALSE, 3);
711 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
713 label = new_info_label_in_frame(box, "IO");
714 gtk_label_set_text(GTK_LABEL(label), io_p);
715 label = new_info_label_in_frame(box, "Bandwidth");
716 gtk_label_set_text(GTK_LABEL(label), bw_p);
717 label = new_info_label_in_frame(box, "IOPS");
718 gtk_label_set_text(GTK_LABEL(label), iops_p);
719 label = new_info_label_in_frame(box, "Runtime (msec)");
720 label_set_int_value(label, ts->runtime[ddir]);
722 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
723 double p_of_agg = 100.0;
724 const char *bw_str = "KB";
728 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
729 if (p_of_agg > 100.0)
733 if (mean[0] > 999999.9) {
741 sprintf(tmp, "Bandwidth (%s)", bw_str);
742 frame = gtk_frame_new(tmp);
743 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
745 box = gtk_hbox_new(FALSE, 3);
746 gtk_container_add(GTK_CONTAINER(frame), box);
748 label = new_info_label_in_frame(box, "Minimum");
749 label_set_int_value(label, min[0]);
750 label = new_info_label_in_frame(box, "Maximum");
751 label_set_int_value(label, max[0]);
752 label = new_info_label_in_frame(box, "Percentage of jobs");
753 sprintf(tmp, "%3.2f%%", p_of_agg);
754 gtk_label_set_text(GTK_LABEL(label), tmp);
755 label = new_info_label_in_frame(box, "Average");
756 sprintf(tmp, "%5.02f", mean[0]);
757 gtk_label_set_text(GTK_LABEL(label), tmp);
758 label = new_info_label_in_frame(box, "Standard deviation");
759 sprintf(tmp, "%5.02f", dev[0]);
760 gtk_label_set_text(GTK_LABEL(label), tmp);
763 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
765 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
767 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
771 frame = gtk_frame_new("Latency");
772 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
774 vbox = gtk_vbox_new(FALSE, 3);
775 gtk_container_add(GTK_CONTAINER(frame), vbox);
777 if (flags & GFIO_SLAT)
778 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
779 if (flags & GFIO_CLAT)
780 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
781 if (flags & GFIO_LAT)
782 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
785 if (ts->clat_percentiles)
786 gfio_show_clat_percentiles(main_vbox, ts, ddir);
794 static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
797 GtkWidget *tree_view;
798 GtkTreeSelection *selection;
805 * Check if all are empty, in which case don't bother
807 for (i = 0, skipped = 0; i < num; i++)
814 types = malloc(num * sizeof(GType));
816 for (i = 0; i < num; i++)
817 types[i] = G_TYPE_STRING;
819 model = gtk_list_store_newv(num, types);
823 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
824 gtk_widget_set_can_focus(tree_view, FALSE);
826 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
827 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
829 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
830 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
832 for (i = 0; i < num; i++)
833 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
835 gtk_list_store_append(model, &iter);
837 for (i = 0; i < num; i++) {
841 sprintf(fbuf, "0.00");
843 sprintf(fbuf, "%3.2f%%", lat[i]);
845 gtk_list_store_set(model, &iter, i, fbuf, -1);
851 static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
853 GtkWidget *box, *frame, *tree_view;
854 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
855 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
856 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
857 "250", "500", "750", "1000", };
858 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
859 "250", "500", "750", "1000", "2000",
862 stat_calc_lat_u(ts, io_u_lat_u);
863 stat_calc_lat_m(ts, io_u_lat_m);
865 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
867 frame = gtk_frame_new("Latency buckets (usec)");
868 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
870 box = gtk_hbox_new(FALSE, 3);
871 gtk_container_add(GTK_CONTAINER(frame), box);
872 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
875 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
877 frame = gtk_frame_new("Latency buckets (msec)");
878 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
880 box = gtk_hbox_new(FALSE, 3);
881 gtk_container_add(GTK_CONTAINER(frame), box);
882 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
886 static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
888 GtkWidget *box, *frame, *entry;
889 double usr_cpu, sys_cpu;
890 unsigned long runtime;
893 runtime = ts->total_run_time;
895 double runt = (double) runtime;
897 usr_cpu = (double) ts->usr_time * 100 / runt;
898 sys_cpu = (double) ts->sys_time * 100 / runt;
904 frame = gtk_frame_new("OS resources");
905 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
907 box = gtk_hbox_new(FALSE, 3);
908 gtk_container_add(GTK_CONTAINER(frame), box);
910 entry = new_info_entry_in_frame(box, "User CPU");
911 sprintf(tmp, "%3.2f%%", usr_cpu);
912 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
913 entry = new_info_entry_in_frame(box, "System CPU");
914 sprintf(tmp, "%3.2f%%", sys_cpu);
915 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
916 entry = new_info_entry_in_frame(box, "Context switches");
917 entry_set_int_value(entry, ts->ctx);
918 entry = new_info_entry_in_frame(box, "Major faults");
919 entry_set_int_value(entry, ts->majf);
920 entry = new_info_entry_in_frame(box, "Minor faults");
921 entry_set_int_value(entry, ts->minf);
923 static void gfio_add_sc_depths_tree(GtkListStore *model,
924 struct thread_stat *ts, unsigned int len,
927 double io_u_dist[FIO_IO_U_MAP_NR];
929 /* Bits 0, and 3-8 */
930 const int add_mask = 0x1f9;
934 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
936 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
938 gtk_list_store_append(model, &iter);
940 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
942 for (i = 1, j = 0; i < len; i++) {
945 if (!(add_mask & (1UL << (i - 1))))
946 sprintf(fbuf, "0.0%%");
948 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
952 gtk_list_store_set(model, &iter, i, fbuf, -1);
957 static void gfio_add_total_depths_tree(GtkListStore *model,
958 struct thread_stat *ts, unsigned int len)
960 double io_u_dist[FIO_IO_U_MAP_NR];
962 /* Bits 1-6, and 8 */
963 const int add_mask = 0x17e;
966 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
968 gtk_list_store_append(model, &iter);
970 gtk_list_store_set(model, &iter, 0, "Total", -1);
972 for (i = 1, j = 0; i < len; i++) {
975 if (!(add_mask & (1UL << (i - 1))))
976 sprintf(fbuf, "0.0%%");
978 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
982 gtk_list_store_set(model, &iter, i, fbuf, -1);
987 static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
989 GtkWidget *frame, *box, *tree_view;
990 GtkTreeSelection *selection;
992 GType types[FIO_IO_U_MAP_NR + 1];
995 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
997 frame = gtk_frame_new("IO depths");
998 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1000 box = gtk_hbox_new(FALSE, 3);
1001 gtk_container_add(GTK_CONTAINER(frame), box);
1003 for (i = 0; i < NR_LABELS; i++)
1004 types[i] = G_TYPE_STRING;
1006 model = gtk_list_store_newv(NR_LABELS, types);
1008 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
1009 gtk_widget_set_can_focus(tree_view, FALSE);
1011 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
1012 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
1014 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
1015 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
1017 for (i = 0; i < NR_LABELS; i++)
1018 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
1020 gfio_add_total_depths_tree(model, ts, NR_LABELS);
1021 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
1022 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
1024 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
1027 static gboolean results_window_delete(GtkWidget *w, gpointer data)
1029 struct gui_entry *ge = (struct gui_entry *) data;
1031 gtk_widget_destroy(w);
1032 ge->results_window = NULL;
1033 ge->results_notebook = NULL;
1037 static GtkWidget *get_results_window(struct gui_entry *ge)
1039 GtkWidget *win, *notebook;
1041 if (ge->results_window)
1042 return ge->results_notebook;
1044 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1045 gtk_window_set_title(GTK_WINDOW(win), "Results");
1046 gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768);
1047 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
1048 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
1050 notebook = gtk_notebook_new();
1051 gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
1052 gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
1053 gtk_container_add(GTK_CONTAINER(win), notebook);
1055 ge->results_window = win;
1056 ge->results_notebook = notebook;
1057 return ge->results_notebook;
1060 static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
1061 struct group_run_stats *rs)
1063 GtkWidget *res_win, *box, *vbox, *entry, *scroll;
1064 struct gfio_client *gc = client->client_data;
1066 gdk_threads_enter();
1068 res_win = get_results_window(gc->ge);
1070 scroll = gtk_scrolled_window_new(NULL, NULL);
1071 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1072 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1074 vbox = gtk_vbox_new(FALSE, 3);
1076 box = gtk_hbox_new(FALSE, 0);
1077 gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5);
1079 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
1081 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name));
1083 gc->results_widget = vbox;
1085 entry = new_info_entry_in_frame(box, "Name");
1086 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
1087 if (strlen(ts->description)) {
1088 entry = new_info_entry_in_frame(box, "Description");
1089 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
1091 entry = new_info_entry_in_frame(box, "Group ID");
1092 entry_set_int_value(entry, ts->groupid);
1093 entry = new_info_entry_in_frame(box, "Jobs");
1094 entry_set_int_value(entry, ts->members);
1095 gc->err_entry = entry = new_info_entry_in_frame(box, "Error");
1096 entry_set_int_value(entry, ts->error);
1097 entry = new_info_entry_in_frame(box, "PID");
1098 entry_set_int_value(entry, ts->pid);
1100 if (ts->io_bytes[DDIR_READ])
1101 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
1102 if (ts->io_bytes[DDIR_WRITE])
1103 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
1105 gfio_show_latency_buckets(vbox, ts);
1106 gfio_show_cpu_usage(vbox, ts);
1107 gfio_show_io_depths(vbox, ts);
1109 gtk_widget_show_all(gc->ge->results_window);
1110 gdk_threads_leave();
1113 static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
1115 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
1116 struct gui *ui = &main_ui;
1120 char tmp[64], timebuf[80];
1123 tm = localtime(&sec);
1124 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
1125 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
1127 gdk_threads_enter();
1129 gtk_list_store_append(ui->log_model, &iter);
1130 gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1);
1131 gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1);
1132 gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1);
1133 gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1);
1135 if (p->level == FIO_LOG_ERR)
1136 view_log(NULL, (gpointer) ui);
1138 gdk_threads_leave();
1141 static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
1143 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
1144 struct gfio_client *gc = client->client_data;
1145 GtkWidget *box, *frame, *entry, *vbox;
1149 gdk_threads_enter();
1151 if (!gc->results_widget)
1154 if (!gc->disk_util_frame) {
1155 gc->disk_util_frame = gtk_frame_new("Disk utilization");
1156 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
1159 vbox = gtk_vbox_new(FALSE, 3);
1160 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
1162 frame = gtk_frame_new((char *) p->dus.name);
1163 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
1165 box = gtk_vbox_new(FALSE, 3);
1166 gtk_container_add(GTK_CONTAINER(frame), box);
1168 frame = gtk_frame_new("Read");
1169 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1170 vbox = gtk_hbox_new(TRUE, 3);
1171 gtk_container_add(GTK_CONTAINER(frame), vbox);
1172 entry = new_info_entry_in_frame(vbox, "IOs");
1173 entry_set_int_value(entry, p->dus.ios[0]);
1174 entry = new_info_entry_in_frame(vbox, "Merges");
1175 entry_set_int_value(entry, p->dus.merges[0]);
1176 entry = new_info_entry_in_frame(vbox, "Sectors");
1177 entry_set_int_value(entry, p->dus.sectors[0]);
1178 entry = new_info_entry_in_frame(vbox, "Ticks");
1179 entry_set_int_value(entry, p->dus.ticks[0]);
1181 frame = gtk_frame_new("Write");
1182 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1183 vbox = gtk_hbox_new(TRUE, 3);
1184 gtk_container_add(GTK_CONTAINER(frame), vbox);
1185 entry = new_info_entry_in_frame(vbox, "IOs");
1186 entry_set_int_value(entry, p->dus.ios[1]);
1187 entry = new_info_entry_in_frame(vbox, "Merges");
1188 entry_set_int_value(entry, p->dus.merges[1]);
1189 entry = new_info_entry_in_frame(vbox, "Sectors");
1190 entry_set_int_value(entry, p->dus.sectors[1]);
1191 entry = new_info_entry_in_frame(vbox, "Ticks");
1192 entry_set_int_value(entry, p->dus.ticks[1]);
1194 frame = gtk_frame_new("Shared");
1195 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1196 vbox = gtk_hbox_new(TRUE, 3);
1197 gtk_container_add(GTK_CONTAINER(frame), vbox);
1198 entry = new_info_entry_in_frame(vbox, "IO ticks");
1199 entry_set_int_value(entry, p->dus.io_ticks);
1200 entry = new_info_entry_in_frame(vbox, "Time in queue");
1201 entry_set_int_value(entry, p->dus.time_in_queue);
1205 util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec;
1209 sprintf(tmp, "%3.2f%%", util);
1210 entry = new_info_entry_in_frame(vbox, "Disk utilization");
1211 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
1213 gtk_widget_show_all(gc->results_widget);
1215 gdk_threads_leave();
1218 extern int sum_stat_clients;
1219 extern struct thread_stat client_ts;
1220 extern struct group_run_stats client_gs;
1222 static int sum_stat_nr;
1224 static void gfio_thread_status_op(struct fio_client *client,
1225 struct fio_net_cmd *cmd)
1227 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
1229 gfio_display_ts(client, &p->ts, &p->rs);
1231 if (sum_stat_clients == 1)
1234 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
1235 sum_group_stats(&client_gs, &p->rs);
1237 client_ts.members++;
1238 client_ts.groupid = p->ts.groupid;
1240 if (++sum_stat_nr == sum_stat_clients) {
1241 strcpy(client_ts.name, "All clients");
1242 gfio_display_ts(client, &client_ts, &client_gs);
1246 static void gfio_group_stats_op(struct fio_client *client,
1247 struct fio_net_cmd *cmd)
1249 /* We're ignoring group stats for now */
1252 static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
1255 struct gfio_graphs *g = data;
1257 graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height);
1258 graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0);
1259 graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height);
1260 graph_set_position(g->bandwidth_graph, 0, 0);
1264 static void draw_graph(struct graph *g, cairo_t *cr)
1266 line_graph_draw(g, cr);
1270 static gboolean graph_tooltip(GtkWidget *w, gint x, gint y,
1271 gboolean keyboard_mode, GtkTooltip *tooltip,
1274 struct gfio_graphs *g = data;
1275 const char *text = NULL;
1277 if (graph_contains_xy(g->iops_graph, x, y))
1278 text = graph_find_tooltip(g->iops_graph, x, y);
1279 else if (graph_contains_xy(g->bandwidth_graph, x, y))
1280 text = graph_find_tooltip(g->bandwidth_graph, x, y);
1283 gtk_tooltip_set_text(tooltip, text);
1290 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1292 struct gfio_graphs *g = p;
1295 cr = gdk_cairo_create(w->window);
1297 if (graph_has_tooltips(g->iops_graph) ||
1298 graph_has_tooltips(g->bandwidth_graph)) {
1299 g_object_set(w, "has-tooltip", TRUE, NULL);
1300 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g);
1303 cairo_set_source_rgb(cr, 0, 0, 0);
1304 draw_graph(g->iops_graph, cr);
1305 draw_graph(g->bandwidth_graph, cr);
1312 * Client specific ETA
1314 static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je)
1316 struct gfio_client *gc = client->client_data;
1317 struct gui_entry *ge = gc->ge;
1318 static int eta_good;
1325 gdk_threads_enter();
1330 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1331 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1332 eta_to_str(eta_str, je->eta_sec);
1335 sprintf(tmp, "%u", je->nr_running);
1336 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), tmp);
1337 sprintf(tmp, "%u", je->files_open);
1338 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), tmp);
1341 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1342 if (je->m_rate || je->t_rate) {
1345 mr = num2str(je->m_rate, 4, 0, i2p);
1346 tr = num2str(je->t_rate, 4, 0, i2p);
1347 gtk_entry_set_text(GTK_ENTRY(ge->eta);
1348 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1351 } else if (je->m_iops || je->t_iops)
1352 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1354 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_bw), "---");
1355 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---");
1356 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---");
1357 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_iops), "---");
1360 if (je->eta_sec != INT_MAX && je->nr_running) {
1364 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1365 strcpy(output, "-.-% done");
1369 sprintf(output, "%3.1f%% done", perc);
1372 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1373 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1375 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1376 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1378 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), rate_str[0]);
1379 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]);
1380 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]);
1381 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]);
1383 graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]);
1384 graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]);
1385 graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]);
1386 graph_add_xy_data(ge->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]);
1395 char *dst = output + strlen(output);
1397 sprintf(dst, " - %s", eta_str);
1400 gfio_update_thread_status(ge, output, perc);
1401 gdk_threads_leave();
1405 * Update ETA in main window for all clients
1407 static void gfio_update_all_eta(struct jobs_eta *je)
1409 struct gui *ui = &main_ui;
1410 static int eta_good;
1416 gdk_threads_enter();
1421 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1422 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1423 eta_to_str(eta_str, je->eta_sec);
1427 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1428 if (je->m_rate || je->t_rate) {
1431 mr = num2str(je->m_rate, 4, 0, i2p);
1432 tr = num2str(je->t_rate, 4, 0, i2p);
1433 gtk_entry_set_text(GTK_ENTRY(ui->eta);
1434 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1437 } else if (je->m_iops || je->t_iops)
1438 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1440 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_bw), "---");
1441 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_iops), "---");
1442 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_bw), "---");
1443 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_iops), "---");
1446 entry_set_int_value(ui->eta.jobs, je->nr_running);
1448 if (je->eta_sec != INT_MAX && je->nr_running) {
1452 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1453 strcpy(output, "-.-% done");
1457 sprintf(output, "%3.1f%% done", perc);
1460 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1461 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1463 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1464 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1466 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), rate_str[0]);
1467 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), iops_str[0]);
1468 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), rate_str[1]);
1469 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), iops_str[1]);
1471 graph_add_xy_data(ui->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]);
1472 graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]);
1473 graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]);
1474 graph_add_xy_data(ui->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]);
1483 char *dst = output + strlen(output);
1485 sprintf(dst, " - %s", eta_str);
1488 gfio_update_thread_status_all(output, perc);
1489 gdk_threads_leave();
1492 static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1494 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
1495 struct gfio_client *gc = client->client_data;
1496 struct gui_entry *ge = gc->ge;
1497 const char *os, *arch;
1500 os = fio_get_os_string(probe->os);
1504 arch = fio_get_arch_string(probe->arch);
1509 client->name = strdup((char *) probe->hostname);
1511 gdk_threads_enter();
1513 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname);
1514 gtk_label_set_text(GTK_LABEL(ge->probe.os), os);
1515 gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch);
1516 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
1517 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf);
1519 gfio_set_state(ge, GE_STATE_CONNECTED);
1521 gdk_threads_leave();
1524 static void gfio_update_thread_status(struct gui_entry *ge,
1525 char *status_message, double perc)
1527 static char message[100];
1528 const char *m = message;
1530 strncpy(message, status_message, sizeof(message) - 1);
1531 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m);
1532 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0);
1533 gtk_widget_queue_draw(main_ui.window);
1536 static void gfio_update_thread_status_all(char *status_message, double perc)
1538 struct gui *ui = &main_ui;
1539 static char message[100];
1540 const char *m = message;
1542 strncpy(message, status_message, sizeof(message) - 1);
1543 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m);
1544 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0);
1545 gtk_widget_queue_draw(ui->window);
1548 static void gfio_quit_op(struct fio_client *client, struct fio_net_cmd *cmd)
1550 struct gfio_client *gc = client->client_data;
1552 gdk_threads_enter();
1553 gfio_set_state(gc->ge, GE_STATE_NEW);
1554 gdk_threads_leave();
1557 static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1559 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
1560 struct gfio_client *gc = client->client_data;
1561 struct thread_options *o = &gc->o;
1562 struct gui_entry *ge = gc->ge;
1565 convert_thread_options_to_cpu(o, &p->top);
1567 gdk_threads_enter();
1569 gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name);
1571 gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name);
1572 gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0);
1574 multitext_add_entry(&ge->eta.iotype, ddir_str(o->td_ddir));
1575 multitext_add_entry(&ge->eta.ioengine, (const char *) o->ioengine);
1577 sprintf(tmp, "%u", o->iodepth);
1578 multitext_add_entry(&ge->eta.iodepth, tmp);
1580 multitext_set_entry(&ge->eta.iotype, 0);
1581 multitext_set_entry(&ge->eta.ioengine, 0);
1582 multitext_set_entry(&ge->eta.iodepth, 0);
1586 gfio_set_state(ge, GE_STATE_JOB_SENT);
1588 gdk_threads_leave();
1591 static void gfio_client_timed_out(struct fio_client *client)
1593 struct gfio_client *gc = client->client_data;
1596 gdk_threads_enter();
1598 gfio_set_state(gc->ge, GE_STATE_NEW);
1599 clear_ge_ui_info(gc->ge);
1601 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1602 show_info_dialog(gc->ge->ui, "Network timeout", buf);
1604 gdk_threads_leave();
1607 static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd)
1609 struct gfio_client *gc = client->client_data;
1611 gdk_threads_enter();
1613 gfio_set_state(gc->ge, GE_STATE_JOB_DONE);
1616 entry_set_int_value(gc->err_entry, client->error);
1618 gdk_threads_leave();
1621 static void gfio_client_start(struct fio_client *client, struct fio_net_cmd *cmd)
1623 struct gfio_client *gc = client->client_data;
1625 gdk_threads_enter();
1626 gfio_set_state(gc->ge, GE_STATE_JOB_STARTED);
1627 gdk_threads_leave();
1630 static void gfio_client_job_start(struct fio_client *client, struct fio_net_cmd *cmd)
1632 struct gfio_client *gc = client->client_data;
1634 gdk_threads_enter();
1635 gfio_set_state(gc->ge, GE_STATE_JOB_RUNNING);
1636 gdk_threads_leave();
1639 static void gfio_client_iolog(struct fio_client *client, struct cmd_iolog_pdu *pdu)
1644 struct client_ops gfio_client_ops = {
1645 .text = gfio_text_op,
1646 .disk_util = gfio_disk_util_op,
1647 .thread_status = gfio_thread_status_op,
1648 .group_stats = gfio_group_stats_op,
1649 .jobs_eta = gfio_update_client_eta,
1650 .eta = gfio_update_all_eta,
1651 .probe = gfio_probe_op,
1652 .quit = gfio_quit_op,
1653 .add_job = gfio_add_job_op,
1654 .timed_out = gfio_client_timed_out,
1655 .stop = gfio_client_stop,
1656 .start = gfio_client_start,
1657 .job_start = gfio_client_job_start,
1658 .iolog = gfio_client_iolog,
1659 .eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
1660 .stay_connected = 1,
1661 .client_type = FIO_CLIENT_TYPE_GUI,
1665 * FIXME: need more handling here
1667 static void ge_destroy(struct gui_entry *ge)
1669 struct gfio_client *gc = ge->client;
1671 if (gc && gc->client) {
1672 if (ge->state >= GE_STATE_CONNECTED)
1673 fio_client_terminate(gc->client);
1675 fio_put_client(gc->client);
1678 flist_del(&ge->list);
1682 static void ge_widget_destroy(GtkWidget *w, gpointer data)
1684 struct gui_entry *ge = data;
1687 * Why are we getting NULL data here sometimes?
1693 static void gfio_quit(struct gui *ui)
1695 struct gui_entry *ge;
1697 while (!flist_empty(&ui->list)) {
1698 ge = flist_entry(ui->list.next, struct gui_entry, list);
1705 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1706 __attribute__((unused)) gpointer data)
1711 static void *job_thread(void *arg)
1713 struct gui *ui = arg;
1715 ui->handler_running = 1;
1716 fio_handle_clients(&gfio_client_ops);
1717 ui->handler_running = 0;
1721 static int send_job_files(struct gui_entry *ge)
1723 struct gfio_client *gc = ge->client;
1726 for (i = 0; i < ge->nr_job_files; i++) {
1727 ret = fio_client_send_ini(gc->client, ge->job_files[i]);
1731 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret));
1732 report_error(error);
1733 g_error_free(error);
1738 free(ge->job_files[i]);
1739 ge->job_files[i] = NULL;
1741 while (i < ge->nr_job_files) {
1742 free(ge->job_files[i]);
1743 ge->job_files[i] = NULL;
1747 free(ge->job_files);
1748 ge->job_files = NULL;
1749 ge->nr_job_files = 0;
1753 static void *server_thread(void *arg)
1756 gfio_server_running = 1;
1757 fio_start_server(NULL);
1758 gfio_server_running = 0;
1762 static void gfio_start_server(void)
1764 struct gui *ui = &main_ui;
1766 if (!gfio_server_running) {
1767 gfio_server_running = 1;
1768 pthread_create(&ui->server_t, NULL, server_thread, NULL);
1769 pthread_detach(ui->server_t);
1773 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
1776 struct gui_entry *ge = data;
1777 struct gfio_client *gc = ge->client;
1780 fio_start_client(gc->client);
1783 static void file_open(GtkWidget *w, gpointer data);
1785 static void connect_clicked(GtkWidget *widget, gpointer data)
1787 struct gui_entry *ge = data;
1788 struct gfio_client *gc = ge->client;
1790 if (ge->state == GE_STATE_NEW) {
1793 if (!ge->nr_job_files)
1794 file_open(widget, ge->ui);
1795 if (!ge->nr_job_files)
1798 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
1799 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
1800 ret = fio_client_connect(gc->client);
1802 if (!ge->ui->handler_running)
1803 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
1804 gfio_set_state(ge, GE_STATE_CONNECTED);
1808 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
1809 report_error(error);
1810 g_error_free(error);
1813 fio_client_terminate(gc->client);
1814 gfio_set_state(ge, GE_STATE_NEW);
1815 clear_ge_ui_info(ge);
1819 static void send_clicked(GtkWidget *widget, gpointer data)
1821 struct gui_entry *ge = data;
1823 if (send_job_files(ge)) {
1826 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send one or more job files for client %s", ge->client->client->hostname);
1827 report_error(error);
1828 g_error_free(error);
1830 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
1834 static GtkWidget *add_button(GtkWidget *buttonbox,
1835 struct button_spec *buttonspec, gpointer data)
1837 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
1839 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
1840 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
1841 gtk_widget_set_tooltip_text(button, buttonspec->tooltiptext);
1842 gtk_widget_set_sensitive(button, !buttonspec->start_insensitive);
1847 static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
1852 for (i = 0; i < nbuttons; i++)
1853 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
1856 static void on_info_bar_response(GtkWidget *widget, gint response,
1859 struct gui *ui = &main_ui;
1861 if (response == GTK_RESPONSE_OK) {
1862 gtk_widget_destroy(widget);
1863 ui->error_info_bar = NULL;
1867 void report_error(GError *error)
1869 struct gui *ui = &main_ui;
1871 if (ui->error_info_bar == NULL) {
1872 ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1875 g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1876 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar),
1879 ui->error_label = gtk_label_new(error->message);
1880 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar));
1881 gtk_container_add(GTK_CONTAINER(container), ui->error_label);
1883 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0);
1884 gtk_widget_show_all(ui->vbox);
1887 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1888 gtk_label_set(GTK_LABEL(ui->error_label), buffer);
1892 struct connection_widgets
1899 static void hostname_cb(GtkEntry *entry, gpointer data)
1901 struct connection_widgets *cw = data;
1902 int uses_net = 0, is_localhost = 0;
1907 * Check whether to display the 'auto start backend' box
1908 * or not. Show it if we are a localhost and using network,
1909 * or using a socket.
1911 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1912 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1917 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1918 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1919 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1920 !strcmp(text, "ip6-loopback"))
1924 if (!uses_net || is_localhost) {
1925 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1926 gtk_widget_set_sensitive(cw->button, 1);
1928 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1929 gtk_widget_set_sensitive(cw->button, 0);
1933 static int get_connection_details(char **host, int *port, int *type,
1936 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1937 struct connection_widgets cw;
1940 dialog = gtk_dialog_new_with_buttons("Connection details",
1941 GTK_WINDOW(main_ui.window),
1942 GTK_DIALOG_DESTROY_WITH_PARENT,
1943 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1944 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1946 frame = gtk_frame_new("Hostname / socket name");
1947 /* gtk_dialog_get_content_area() is 2.14 and newer */
1948 vbox = GTK_DIALOG(dialog)->vbox;
1949 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1951 box = gtk_vbox_new(FALSE, 6);
1952 gtk_container_add(GTK_CONTAINER(frame), box);
1954 hbox = gtk_hbox_new(TRUE, 10);
1955 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1956 cw.hentry = gtk_entry_new();
1957 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
1958 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
1960 frame = gtk_frame_new("Port");
1961 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1962 box = gtk_vbox_new(FALSE, 10);
1963 gtk_container_add(GTK_CONTAINER(frame), box);
1965 hbox = gtk_hbox_new(TRUE, 4);
1966 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1967 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1969 frame = gtk_frame_new("Type");
1970 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1971 box = gtk_vbox_new(FALSE, 10);
1972 gtk_container_add(GTK_CONTAINER(frame), box);
1974 hbox = gtk_hbox_new(TRUE, 4);
1975 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1977 cw.combo = gtk_combo_box_new_text();
1978 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
1979 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
1980 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
1981 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
1983 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
1985 frame = gtk_frame_new("Options");
1986 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1987 box = gtk_vbox_new(FALSE, 10);
1988 gtk_container_add(GTK_CONTAINER(frame), box);
1990 hbox = gtk_hbox_new(TRUE, 4);
1991 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1993 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1994 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
1995 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.");
1996 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
1999 * Connect edit signal, so we can show/not-show the auto start button
2001 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
2002 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
2004 gtk_widget_show_all(dialog);
2006 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2007 gtk_widget_destroy(dialog);
2011 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
2012 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
2014 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
2015 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
2016 *type = Fio_client_ipv4;
2017 else if (!strncmp(typeentry, "IPv6", 4))
2018 *type = Fio_client_ipv6;
2020 *type = Fio_client_socket;
2023 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
2025 gtk_widget_destroy(dialog);
2029 static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
2031 struct gfio_client *gc;
2033 gc = malloc(sizeof(*gc));
2034 memset(gc, 0, sizeof(*gc));
2036 gc->client = fio_get_client(client);
2040 client->client_data = gc;
2043 static GtkWidget *new_client_page(struct gui_entry *ge);
2045 static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
2047 struct gui_entry *ge;
2049 ge = malloc(sizeof(*ge));
2050 memset(ge, 0, sizeof(*ge));
2051 ge->state = GE_STATE_NEW;
2052 INIT_FLIST_HEAD(&ge->list);
2053 flist_add_tail(&ge->list, &ui->list);
2058 static struct gui_entry *get_new_ge_with_tab(const char *name)
2060 struct gui_entry *ge;
2062 ge = alloc_new_gui_entry(&main_ui);
2064 ge->vbox = new_client_page(ge);
2065 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge);
2067 ge->page_label = gtk_label_new(name);
2068 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label);
2070 gtk_widget_show_all(main_ui.window);
2074 static void file_new(GtkWidget *w, gpointer data)
2076 struct gui *ui = (struct gui *) data;
2077 struct gui_entry *ge;
2079 ge = get_new_ge_with_tab("Untitled");
2080 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
2084 * Return the 'ge' corresponding to the tab. If the active tab is the
2085 * main tab, open a new tab.
2087 static struct gui_entry *get_ge_from_page(gint cur_page, int *created)
2089 struct flist_head *entry;
2090 struct gui_entry *ge;
2095 return get_new_ge_with_tab("Untitled");
2101 flist_for_each(entry, &main_ui.list) {
2102 ge = flist_entry(entry, struct gui_entry, list);
2103 if (ge->page_num == cur_page)
2110 static struct gui_entry *get_ge_from_cur_tab(struct gui *ui)
2115 * Main tab is tab 0, so any current page other than 0 holds
2118 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
2120 return get_ge_from_page(cur_page, NULL);
2125 static void file_close(GtkWidget *w, gpointer data)
2127 struct gui *ui = (struct gui *) data;
2128 struct gui_entry *ge;
2131 * Can't close the main tab
2133 ge = get_ge_from_cur_tab(ui);
2135 gtk_widget_destroy(ge->vbox);
2139 if (!flist_empty(&ui->list)) {
2140 show_info_dialog(ui, "Error", "The main page view cannot be closed\n");
2147 static void file_add_recent(struct gui *ui, const gchar *uri)
2151 memset(&grd, 0, sizeof(grd));
2152 grd.display_name = strdup("gfio");
2153 grd.description = strdup("Fio job file");
2154 grd.mime_type = strdup(GFIO_MIME);
2155 grd.app_name = strdup(g_get_application_name());
2156 grd.app_exec = strdup("gfio %f/%u");
2158 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd);
2161 static gchar *get_filename_from_uri(const gchar *uri)
2163 if (strncmp(uri, "file://", 7))
2166 return strdup(uri + 7);
2169 static int do_file_open(struct gui_entry *ge, const gchar *uri, char *host,
2172 struct fio_client *client;
2175 filename = get_filename_from_uri(uri);
2177 ge->job_files = realloc(ge->job_files, (ge->nr_job_files + 1) * sizeof(char *));
2178 ge->job_files[ge->nr_job_files] = strdup(filename);
2181 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
2185 error = g_error_new(g_quark_from_string("fio"), 1,
2186 "Failed to add client %s", host);
2187 report_error(error);
2188 g_error_free(error);
2192 gfio_client_added(ge, client);
2193 file_add_recent(ge->ui, uri);
2197 static int do_file_open_with_tab(struct gui *ui, const gchar *uri)
2199 int port, type, server_start;
2200 struct gui_entry *ge;
2203 int ret, ge_is_new = 0;
2206 * Creates new tab if current tab is the main window, or the
2207 * current tab already has a client.
2209 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
2210 ge = get_ge_from_page(cur_page, &ge_is_new);
2212 ge = get_new_ge_with_tab("Untitled");
2216 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
2218 if (get_connection_details(&host, &port, &type, &server_start)) {
2220 gtk_widget_destroy(ge->vbox);
2225 ret = do_file_open(ge, uri, host, type, port);
2231 gfio_start_server();
2234 gtk_widget_destroy(ge->vbox);
2240 static void recent_open(GtkAction *action, gpointer data)
2242 struct gui *ui = (struct gui *) data;
2243 GtkRecentInfo *info;
2246 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
2247 uri = gtk_recent_info_get_uri(info);
2249 do_file_open_with_tab(ui, uri);
2252 static void file_open(GtkWidget *w, gpointer data)
2254 struct gui *ui = data;
2256 GSList *filenames, *fn_glist;
2257 GtkFileFilter *filter;
2259 dialog = gtk_file_chooser_dialog_new("Open File",
2260 GTK_WINDOW(ui->window),
2261 GTK_FILE_CHOOSER_ACTION_OPEN,
2262 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2263 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
2265 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
2267 filter = gtk_file_filter_new();
2268 gtk_file_filter_add_pattern(filter, "*.fio");
2269 gtk_file_filter_add_pattern(filter, "*.job");
2270 gtk_file_filter_add_pattern(filter, "*.ini");
2271 gtk_file_filter_add_mime_type(filter, GFIO_MIME);
2272 gtk_file_filter_set_name(filter, "Fio job file");
2273 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
2275 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2276 gtk_widget_destroy(dialog);
2280 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
2282 gtk_widget_destroy(dialog);
2284 filenames = fn_glist;
2285 while (filenames != NULL) {
2286 if (do_file_open_with_tab(ui, filenames->data))
2288 filenames = g_slist_next(filenames);
2291 g_slist_free(fn_glist);
2294 static void file_save(GtkWidget *w, gpointer data)
2296 struct gui *ui = data;
2299 dialog = gtk_file_chooser_dialog_new("Save File",
2300 GTK_WINDOW(ui->window),
2301 GTK_FILE_CHOOSER_ACTION_SAVE,
2302 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2303 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
2306 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
2307 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
2309 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2312 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
2313 // save_job_file(filename);
2316 gtk_widget_destroy(dialog);
2319 static void view_log_destroy(GtkWidget *w, gpointer data)
2321 struct gui *ui = (struct gui *) data;
2323 gtk_widget_ref(ui->log_tree);
2324 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
2325 gtk_widget_destroy(w);
2326 ui->log_view = NULL;
2329 static void view_log(GtkWidget *w, gpointer data)
2331 GtkWidget *win, *scroll, *vbox, *box;
2332 struct gui *ui = (struct gui *) data;
2337 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2338 gtk_window_set_title(GTK_WINDOW(win), "Log");
2339 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
2341 scroll = gtk_scrolled_window_new(NULL, NULL);
2343 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
2345 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2347 box = gtk_hbox_new(TRUE, 0);
2348 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
2349 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
2350 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
2352 vbox = gtk_vbox_new(TRUE, 5);
2353 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
2355 gtk_container_add(GTK_CONTAINER(win), vbox);
2356 gtk_widget_show_all(win);
2359 static void connect_job_entry(GtkWidget *w, gpointer data)
2361 struct gui *ui = (struct gui *) data;
2362 struct gui_entry *ge;
2364 ge = get_ge_from_cur_tab(ui);
2366 connect_clicked(w, ge);
2369 static void send_job_entry(GtkWidget *w, gpointer data)
2371 struct gui *ui = (struct gui *) data;
2372 struct gui_entry *ge;
2374 ge = get_ge_from_cur_tab(ui);
2376 send_clicked(w, ge);
2380 static void edit_job_entry(GtkWidget *w, gpointer data)
2384 static void start_job_entry(GtkWidget *w, gpointer data)
2386 struct gui *ui = (struct gui *) data;
2387 struct gui_entry *ge;
2389 ge = get_ge_from_cur_tab(ui);
2391 start_job_clicked(w, ge);
2394 static void __update_graph_limits(struct gfio_graphs *g)
2396 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
2397 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
2400 static void update_graph_limits(void)
2402 struct flist_head *entry;
2403 struct gui_entry *ge;
2405 __update_graph_limits(&main_ui.graphs);
2407 flist_for_each(entry, &main_ui.list) {
2408 ge = flist_entry(entry, struct gui_entry, list);
2409 __update_graph_limits(&ge->graphs);
2413 static void preferences(GtkWidget *w, gpointer data)
2415 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
2416 GtkWidget *hbox, *spin, *entry, *spin_int;
2419 dialog = gtk_dialog_new_with_buttons("Preferences",
2420 GTK_WINDOW(main_ui.window),
2421 GTK_DIALOG_DESTROY_WITH_PARENT,
2422 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2423 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
2426 frame = gtk_frame_new("Graphing");
2427 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2428 vbox = gtk_vbox_new(FALSE, 6);
2429 gtk_container_add(GTK_CONTAINER(frame), vbox);
2431 hbox = gtk_hbox_new(FALSE, 5);
2432 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
2433 entry = gtk_label_new("Font face to use for graph labels");
2434 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
2436 font = gtk_font_button_new();
2437 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
2439 box = gtk_vbox_new(FALSE, 6);
2440 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2442 hbox = gtk_hbox_new(FALSE, 5);
2443 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
2444 entry = gtk_label_new("Maximum number of data points in graph (seconds)");
2445 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2447 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
2449 box = gtk_vbox_new(FALSE, 6);
2450 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2452 hbox = gtk_hbox_new(FALSE, 5);
2453 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
2454 entry = gtk_label_new("Client ETA request interval (msec)");
2455 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2457 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
2458 frame = gtk_frame_new("Debug logging");
2459 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2460 vbox = gtk_vbox_new(FALSE, 6);
2461 gtk_container_add(GTK_CONTAINER(frame), vbox);
2463 box = gtk_hbox_new(FALSE, 6);
2464 gtk_container_add(GTK_CONTAINER(vbox), box);
2466 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
2468 for (i = 0; i < FD_DEBUG_MAX; i++) {
2470 box = gtk_hbox_new(FALSE, 6);
2471 gtk_container_add(GTK_CONTAINER(vbox), box);
2475 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
2476 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
2477 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
2480 gtk_widget_show_all(dialog);
2482 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2483 gtk_widget_destroy(dialog);
2487 for (i = 0; i < FD_DEBUG_MAX; i++) {
2490 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
2492 fio_debug |= (1UL << i);
2495 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
2496 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
2497 update_graph_limits();
2498 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
2500 gtk_widget_destroy(dialog);
2503 static void about_dialog(GtkWidget *w, gpointer data)
2505 const char *authors[] = {
2506 "Jens Axboe <axboe@kernel.dk>",
2507 "Stephen Carmeron <stephenmcameron@gmail.com>",
2510 const char *license[] = {
2511 "Fio is free software; you can redistribute it and/or modify "
2512 "it under the terms of the GNU General Public License as published by "
2513 "the Free Software Foundation; either version 2 of the License, or "
2514 "(at your option) any later version.\n",
2515 "Fio is distributed in the hope that it will be useful, "
2516 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
2517 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
2518 "GNU General Public License for more details.\n",
2519 "You should have received a copy of the GNU General Public License "
2520 "along with Fio; if not, write to the Free Software Foundation, Inc., "
2521 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
2523 char *license_trans;
2525 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
2526 license[2], "\n", NULL);
2528 gtk_show_about_dialog(NULL,
2529 "program-name", "gfio",
2530 "comments", "Gtk2 UI for fio",
2531 "license", license_trans,
2532 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
2534 "version", fio_version_string,
2535 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
2536 "logo-icon-name", "fio",
2538 "wrap-license", TRUE,
2541 g_free(license_trans);
2544 static GtkActionEntry menu_items[] = {
2545 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
2546 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
2547 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL},
2548 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
2549 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
2550 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) },
2551 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
2552 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
2553 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
2554 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
2555 { "ConnectJob", NULL, "Connect", "<Control>E", NULL, G_CALLBACK(connect_job_entry) },
2556 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) },
2557 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) },
2558 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) },
2559 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
2560 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
2562 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
2564 static const gchar *ui_string = " \
2566 <menubar name=\"MainMenu\"> \
2567 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
2568 <menuitem name=\"New\" action=\"NewFile\" /> \
2569 <menuitem name=\"Close\" action=\"CloseFile\" /> \
2570 <separator name=\"Separator1\"/> \
2571 <menuitem name=\"Open\" action=\"OpenFile\" /> \
2572 <menuitem name=\"Save\" action=\"SaveFile\" /> \
2573 <separator name=\"Separator2\"/> \
2574 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
2575 <separator name=\"Separator3\"/> \
2576 <placeholder name=\"FileRecentFiles\"/> \
2577 <separator name=\"Separator4\"/> \
2578 <menuitem name=\"Quit\" action=\"Quit\" /> \
2580 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \
2581 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \
2582 <separator name=\"Separator5\"/> \
2583 <menuitem name=\"Edit job\" action=\"EditJob\" /> \
2584 <menuitem name=\"Send job\" action=\"SendJob\" /> \
2585 <separator name=\"Separator6\"/> \
2586 <menuitem name=\"Start job\" action=\"StartJob\" /> \
2588 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
2589 <menuitem name=\"Log\" action=\"ViewLog\" /> \
2591 <menu name=\"Help\" action=\"HelpMenuAction\"> \
2592 <menuitem name=\"About\" action=\"About\" /> \
2598 static void set_job_menu_visible(struct gui *ui, int visible)
2602 job = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu");
2603 gtk_widget_set_sensitive(job, visible);
2606 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
2609 GtkActionGroup *action_group;
2612 action_group = gtk_action_group_new("Menu");
2613 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
2615 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
2616 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
2618 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
2620 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
2623 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
2624 GtkWidget *vbox, GtkUIManager *ui_manager)
2626 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
2629 static void combo_entry_changed(GtkComboBox *box, gpointer data)
2631 struct gui_entry *ge = (struct gui_entry *) data;
2634 index = gtk_combo_box_get_active(box);
2636 multitext_set_entry(&ge->eta.iotype, index);
2637 multitext_set_entry(&ge->eta.ioengine, index);
2638 multitext_set_entry(&ge->eta.iodepth, index);
2641 static void combo_entry_destroy(GtkWidget *widget, gpointer data)
2643 struct gui_entry *ge = (struct gui_entry *) data;
2645 multitext_free(&ge->eta.iotype);
2646 multitext_free(&ge->eta.ioengine);
2647 multitext_free(&ge->eta.iodepth);
2650 static GtkWidget *new_client_page(struct gui_entry *ge)
2652 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
2653 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
2656 main_vbox = gtk_vbox_new(FALSE, 3);
2658 top_align = gtk_alignment_new(0, 0, 1, 0);
2659 top_vbox = gtk_vbox_new(FALSE, 3);
2660 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
2661 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
2663 probe = gtk_frame_new("Job");
2664 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
2665 probe_frame = gtk_vbox_new(FALSE, 3);
2666 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2668 probe_box = gtk_hbox_new(FALSE, 3);
2669 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2670 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
2671 ge->probe.os = new_info_label_in_frame(probe_box, "OS");
2672 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
2673 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
2675 probe_box = gtk_hbox_new(FALSE, 3);
2676 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2678 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
2679 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge);
2680 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge);
2681 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO");
2682 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine");
2683 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth");
2684 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
2685 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
2687 probe_box = gtk_hbox_new(FALSE, 3);
2688 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2689 ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2690 ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2691 ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2692 ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
2695 * Only add this if we have a commit rate
2698 probe_box = gtk_hbox_new(FALSE, 3);
2699 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
2701 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2702 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2704 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2705 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2709 * Set up a drawing area and IOPS and bandwidth graphs
2711 gdk_color_parse("white", &white);
2712 ge->graphs.drawing_area = gtk_drawing_area_new();
2713 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
2714 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2715 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2716 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event",
2717 G_CALLBACK(on_expose_drawing_area), &ge->graphs);
2718 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
2719 G_CALLBACK(on_config_drawing_area), &ge->graphs);
2720 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2721 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2722 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2723 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
2724 ge->graphs.drawing_area);
2725 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
2727 setup_graphs(&ge->graphs);
2730 * Set up alignments for widgets at the bottom of ui,
2731 * align bottom left, expand horizontally but not vertically
2733 bottom_align = gtk_alignment_new(0, 1, 1, 0);
2734 ge->buttonbox = gtk_hbox_new(FALSE, 0);
2735 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox);
2736 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
2738 add_buttons(ge, buttonspeclist, ARRAYSIZE(buttonspeclist));
2741 * Set up thread status progress bar
2743 ge->thread_status_pb = gtk_progress_bar_new();
2744 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
2745 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
2746 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
2752 static GtkWidget *new_main_page(struct gui *ui)
2754 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
2755 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
2758 main_vbox = gtk_vbox_new(FALSE, 3);
2761 * Set up alignments for widgets at the top of ui,
2762 * align top left, expand horizontally but not vertically
2764 top_align = gtk_alignment_new(0, 0, 1, 0);
2765 top_vbox = gtk_vbox_new(FALSE, 0);
2766 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
2767 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
2769 probe = gtk_frame_new("Run statistics");
2770 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
2771 probe_frame = gtk_vbox_new(FALSE, 3);
2772 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2774 probe_box = gtk_hbox_new(FALSE, 3);
2775 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2776 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
2777 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2778 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2779 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2780 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
2783 * Only add this if we have a commit rate
2786 probe_box = gtk_hbox_new(FALSE, 3);
2787 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
2789 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2790 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2792 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2793 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2797 * Set up a drawing area and IOPS and bandwidth graphs
2799 gdk_color_parse("white", &white);
2800 ui->graphs.drawing_area = gtk_drawing_area_new();
2801 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
2802 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2803 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2804 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event",
2805 G_CALLBACK(on_expose_drawing_area), &ui->graphs);
2806 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
2807 G_CALLBACK(on_config_drawing_area), &ui->graphs);
2808 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2809 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2810 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2811 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
2812 ui->graphs.drawing_area);
2813 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window,
2816 setup_graphs(&ui->graphs);
2819 * Set up alignments for widgets at the bottom of ui,
2820 * align bottom left, expand horizontally but not vertically
2822 bottom_align = gtk_alignment_new(0, 1, 1, 0);
2823 ui->buttonbox = gtk_hbox_new(FALSE, 0);
2824 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox);
2825 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
2828 * Set up thread status progress bar
2830 ui->thread_status_pb = gtk_progress_bar_new();
2831 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
2832 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
2833 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
2838 static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
2839 guint page, gpointer data)
2842 struct gui *ui = (struct gui *) data;
2843 struct gui_entry *ge;
2846 set_job_menu_visible(ui, 0);
2850 set_job_menu_visible(ui, 1);
2851 ge = get_ge_from_page(page, NULL);
2853 update_button_states(ui, ge);
2858 static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b)
2860 time_t time_a = gtk_recent_info_get_visited(a);
2861 time_t time_b = gtk_recent_info_get_visited(b);
2863 return time_b - time_a;
2866 static void add_recent_file_items(struct gui *ui)
2868 const gchar *gfio = g_get_application_name();
2869 GList *items, *item;
2872 if (ui->recent_ui_id) {
2873 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id);
2874 gtk_ui_manager_ensure_update(ui->uimanager);
2876 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager);
2878 if (ui->actiongroup) {
2879 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup);
2880 g_object_unref(ui->actiongroup);
2882 ui->actiongroup = gtk_action_group_new("RecentFileActions");
2884 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1);
2886 items = gtk_recent_manager_get_items(ui->recentmanager);
2887 items = g_list_sort(items, (GCompareFunc) compare_recent_items);
2889 for (item = items; item && item->data; item = g_list_next(item)) {
2890 GtkRecentInfo *info = (GtkRecentInfo *) item->data;
2895 if (!gtk_recent_info_has_application(info, gfio))
2899 * We only support local files for now
2901 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info))
2904 action_name = g_strdup_printf("RecentFile%u", i++);
2905 label = gtk_recent_info_get_display_name(info);
2907 action = g_object_new(GTK_TYPE_ACTION,
2908 "name", action_name,
2909 "label", label, NULL);
2911 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info",
2912 gtk_recent_info_ref(info),
2913 (GDestroyNotify) gtk_recent_info_unref);
2916 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui);
2918 gtk_action_group_add_action(ui->actiongroup, action);
2919 g_object_unref(action);
2921 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id,
2922 "/MainMenu/FileMenu/FileRecentFiles",
2924 GTK_UI_MANAGER_MENUITEM, FALSE);
2926 g_free(action_name);
2932 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL);
2936 static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx,
2937 gint x, gint y, GtkSelectionData *data,
2938 guint info, guint time)
2940 struct gui *ui = &main_ui;
2945 source = gtk_drag_get_source_widget(ctx);
2946 if (source && widget == gtk_widget_get_toplevel(source)) {
2947 gtk_drag_finish(ctx, FALSE, FALSE, time);
2951 uris = gtk_selection_data_get_uris(data);
2953 gtk_drag_finish(ctx, FALSE, FALSE, time);
2959 if (do_file_open_with_tab(ui, uris[i]))
2964 gtk_drag_finish(ctx, TRUE, FALSE, time);
2968 static void init_ui(int *argc, char **argv[], struct gui *ui)
2970 GtkSettings *settings;
2973 /* Magical g*thread incantation, you just need this thread stuff.
2974 * Without it, the update that happens in gfio_update_thread_status
2975 * doesn't really happen in a timely fashion, you need expose events
2977 if (!g_thread_supported())
2978 g_thread_init(NULL);
2981 gtk_init(argc, argv);
2982 settings = gtk_settings_get_default();
2983 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
2986 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2987 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
2988 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
2990 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
2991 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
2993 ui->vbox = gtk_vbox_new(FALSE, 0);
2994 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
2996 ui->uimanager = gtk_ui_manager_new();
2997 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui);
2998 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager);
3000 ui->recentmanager = gtk_recent_manager_get_default();
3001 add_recent_file_items(ui);
3003 ui->notebook = gtk_notebook_new();
3004 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
3005 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
3006 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
3007 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
3009 vbox = new_main_page(ui);
3010 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
3011 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window));
3012 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui);
3014 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
3016 gfio_ui_setup_log(ui);
3018 gtk_widget_show_all(ui->window);
3021 int main(int argc, char *argv[], char *envp[])
3023 if (initialize_fio(envp))
3025 if (fio_init_options())
3028 memset(&main_ui, 0, sizeof(main_ui));
3029 INIT_FLIST_HEAD(&main_ui.list);
3031 init_ui(&argc, &argv, &main_ui);
3033 gdk_threads_enter();
3035 gdk_threads_leave();