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 GtkUIManager *results_uimanager;
162 GtkWidget *results_vbox;
163 GtkWidget *results_menu;
164 GtkListStore *log_model;
167 struct gfio_graphs graphs;
168 struct probe_widget probe;
169 struct eta_widget eta;
170 GtkWidget *page_label;
174 struct gfio_client *client;
180 struct gui_entry *ge;
181 struct fio_client *client;
182 GtkWidget *results_widget;
183 GtkWidget *disk_util_frame;
184 GtkWidget *err_entry;
185 unsigned int job_added;
186 struct thread_options o;
189 static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
190 static void gfio_update_thread_status_all(char *status_message, double perc);
191 void report_error(GError *error);
193 static struct graph *setup_iops_graph(void)
197 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
198 graph_title(g, "IOPS (IOs/sec)");
199 graph_x_title(g, "Time (secs)");
200 graph_add_label(g, "Read IOPS");
201 graph_add_label(g, "Write IOPS");
202 graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
203 graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
204 line_graph_set_data_count_limit(g, gfio_graph_limit);
205 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
209 static struct graph *setup_bandwidth_graph(void)
213 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
214 graph_title(g, "Bandwidth (bytes/sec)");
215 graph_x_title(g, "Time (secs)");
216 graph_add_label(g, "Read Bandwidth");
217 graph_add_label(g, "Write Bandwidth");
218 graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
219 graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
220 graph_set_base_offset(g, 1);
221 line_graph_set_data_count_limit(g, 100);
222 graph_add_extra_space(g, 0.0, 0.0, 0.0, 0.0);
226 static void setup_graphs(struct gfio_graphs *g)
228 g->iops_graph = setup_iops_graph();
229 g->bandwidth_graph = setup_bandwidth_graph();
232 static void multitext_add_entry(struct multitext_widget *mt, const char *text)
234 mt->text = realloc(mt->text, (mt->max_text + 1) * sizeof(char *));
235 mt->text[mt->max_text] = strdup(text);
239 static void multitext_set_entry(struct multitext_widget *mt, unsigned int index)
241 if (index >= mt->max_text)
243 if (!mt->text || !mt->text[index])
246 mt->cur_text = index;
247 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
250 static void multitext_update_entry(struct multitext_widget *mt,
251 unsigned int index, const char *text)
257 free(mt->text[index]);
259 mt->text[index] = strdup(text);
260 if (mt->cur_text == index)
261 gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
264 static void multitext_free(struct multitext_widget *mt)
268 gtk_entry_set_text(GTK_ENTRY(mt->entry), "");
270 for (i = 0; i < mt->max_text; i++) {
280 static void clear_ge_ui_info(struct gui_entry *ge)
282 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
283 gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
284 gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
285 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
287 /* should we empty it... */
288 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
290 multitext_update_entry(&ge->eta.iotype, 0, "");
291 multitext_update_entry(&ge->eta.ioengine, 0, "");
292 multitext_update_entry(&ge->eta.iodepth, 0, "");
293 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
294 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
295 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
296 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
297 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
298 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
301 static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label)
303 GtkWidget *entry, *frame;
305 frame = gtk_frame_new(label);
306 entry = gtk_combo_box_new_text();
307 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
308 gtk_container_add(GTK_CONTAINER(frame), entry);
313 static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
315 GtkWidget *entry, *frame;
317 frame = gtk_frame_new(label);
318 entry = gtk_entry_new();
319 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
320 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
321 gtk_container_add(GTK_CONTAINER(frame), entry);
326 static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
328 GtkWidget *label_widget;
331 frame = gtk_frame_new(label);
332 label_widget = gtk_label_new(NULL);
333 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
334 gtk_container_add(GTK_CONTAINER(frame), label_widget);
339 static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
341 GtkWidget *button, *box;
343 box = gtk_hbox_new(FALSE, 3);
344 gtk_container_add(GTK_CONTAINER(hbox), box);
346 button = gtk_spin_button_new_with_range(min, max, 1.0);
347 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
349 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
350 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
355 static void label_set_int_value(GtkWidget *entry, unsigned int val)
359 sprintf(tmp, "%u", val);
360 gtk_label_set_text(GTK_LABEL(entry), tmp);
363 static void entry_set_int_value(GtkWidget *entry, unsigned int val)
367 sprintf(tmp, "%u", val);
368 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
371 static void show_info_dialog(struct gui *ui, const char *title,
374 GtkWidget *dialog, *content, *label;
376 dialog = gtk_dialog_new_with_buttons(title, GTK_WINDOW(ui->window),
377 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
378 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
380 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
381 label = gtk_label_new(message);
382 gtk_container_add(GTK_CONTAINER(content), label);
383 gtk_widget_show_all(dialog);
384 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
385 gtk_dialog_run(GTK_DIALOG(dialog));
386 gtk_widget_destroy(dialog);
390 * Update sensitivity of job buttons and job menu items, based on the
391 * state of the client.
393 static void update_button_states(struct gui *ui, struct gui_entry *ge)
395 unsigned int connect_state, send_state, start_state, edit_state;
396 const char *connect_str = NULL;
403 sprintf(tmp, "Bad client state: %u\n", ge->state);
404 show_info_dialog(ui, "Error", tmp);
405 /* fall through to new state */
411 connect_str = "Connect";
415 case GE_STATE_CONNECTED:
418 connect_str = "Disconnect";
422 case GE_STATE_JOB_SENT:
425 connect_str = "Disconnect";
429 case GE_STATE_JOB_STARTED:
432 connect_str = "Disconnect";
436 case GE_STATE_JOB_RUNNING:
439 connect_str = "Disconnect";
443 case GE_STATE_JOB_DONE:
446 connect_str = "Connect";
452 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], connect_state);
453 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], send_state);
454 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], start_state);
455 gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), connect_str);
457 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Connect");
458 gtk_widget_set_sensitive(w, connect_state);
459 gtk_menu_item_set_label(GTK_MENU_ITEM(w), connect_str);
461 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Edit job");
462 gtk_widget_set_sensitive(w, edit_state);
464 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Send job");
465 gtk_widget_set_sensitive(w, send_state);
467 w = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu/Start job");
468 gtk_widget_set_sensitive(w, start_state);
471 static void gfio_set_state(struct gui_entry *ge, unsigned int state)
474 update_button_states(ge->ui, ge);
478 #define ALIGN_RIGHT 2
482 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
484 GtkCellRenderer *renderer;
485 GtkTreeViewColumn *col;
486 double xalign = 0.0; /* left as default */
487 PangoAlignment align;
490 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
491 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
493 visible = !(flags & INVISIBLE);
495 renderer = gtk_cell_renderer_text_new();
496 col = gtk_tree_view_column_new();
498 gtk_tree_view_column_set_title(col, title);
499 if (!(flags & UNSORTABLE))
500 gtk_tree_view_column_set_sort_column_id(col, index);
501 gtk_tree_view_column_set_resizable(col, TRUE);
502 gtk_tree_view_column_pack_start(col, renderer, TRUE);
503 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
504 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
506 case PANGO_ALIGN_LEFT:
509 case PANGO_ALIGN_CENTER:
512 case PANGO_ALIGN_RIGHT:
516 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
517 gtk_tree_view_column_set_visible(col, visible);
518 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
522 static void gfio_ui_setup_log(struct gui *ui)
524 GtkTreeSelection *selection;
526 GtkWidget *tree_view;
528 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
530 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
531 gtk_widget_set_can_focus(tree_view, FALSE);
533 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
534 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
535 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
536 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
538 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
539 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
540 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
541 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
543 ui->log_model = model;
544 ui->log_tree = tree_view;
547 static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
553 GType types[FIO_IO_U_LIST_MAX_LEN];
554 GtkWidget *tree_view;
555 GtkTreeSelection *selection;
560 for (i = 0; i < len; i++)
561 types[i] = G_TYPE_INT;
563 model = gtk_list_store_newv(len, types);
565 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
566 gtk_widget_set_can_focus(tree_view, FALSE);
568 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
569 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
571 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
572 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
574 for (i = 0; i < len; i++) {
577 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
578 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
581 gtk_list_store_append(model, &iter);
583 for (i = 0; i < len; i++) {
585 ovals[i] = (ovals[i] + 999) / 1000;
586 gtk_list_store_set(model, &iter, i, ovals[i], -1);
592 static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
595 unsigned int *io_u_plat = ts->io_u_plat[ddir];
596 unsigned long nr = ts->clat_stat[ddir].samples;
597 fio_fp64_t *plist = ts->percentile_list;
598 unsigned int *ovals, len, minv, maxv, scale_down;
600 GtkWidget *tree_view, *frame, *hbox;
603 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
608 * We default to usecs, but if the value range is such that we
609 * should scale down to msecs, do that.
611 if (minv > 2000 && maxv > 99999) {
619 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
621 sprintf(tmp, "Completion percentiles (%s)", base);
622 frame = gtk_frame_new(tmp);
623 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
625 hbox = gtk_hbox_new(FALSE, 3);
626 gtk_container_add(GTK_CONTAINER(frame), hbox);
628 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
634 static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
635 unsigned long max, double mean, double dev)
637 const char *base = "(usec)";
638 GtkWidget *hbox, *label, *frame;
642 if (!usec_to_msec(&min, &max, &mean, &dev))
645 minp = num2str(min, 6, 1, 0);
646 maxp = num2str(max, 6, 1, 0);
648 sprintf(tmp, "%s %s", name, base);
649 frame = gtk_frame_new(tmp);
650 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
652 hbox = gtk_hbox_new(FALSE, 3);
653 gtk_container_add(GTK_CONTAINER(frame), hbox);
655 label = new_info_label_in_frame(hbox, "Minimum");
656 gtk_label_set_text(GTK_LABEL(label), minp);
657 label = new_info_label_in_frame(hbox, "Maximum");
658 gtk_label_set_text(GTK_LABEL(label), maxp);
659 label = new_info_label_in_frame(hbox, "Average");
660 sprintf(tmp, "%5.02f", mean);
661 gtk_label_set_text(GTK_LABEL(label), tmp);
662 label = new_info_label_in_frame(hbox, "Standard deviation");
663 sprintf(tmp, "%5.02f", dev);
664 gtk_label_set_text(GTK_LABEL(label), tmp);
675 static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
676 struct thread_stat *ts, int ddir)
678 const char *ddir_label[2] = { "Read", "Write" };
679 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
680 unsigned long min[3], max[3], runt;
681 unsigned long long bw, iops;
682 unsigned int flags = 0;
683 double mean[3], dev[3];
684 char *io_p, *bw_p, *iops_p;
687 if (!ts->runtime[ddir])
690 i2p = is_power_of_2(rs->kb_base);
691 runt = ts->runtime[ddir];
693 bw = (1000 * ts->io_bytes[ddir]) / runt;
694 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
695 bw_p = num2str(bw, 6, 1, i2p);
697 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
698 iops_p = num2str(iops, 6, 1, 0);
700 box = gtk_hbox_new(FALSE, 3);
701 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
703 frame = gtk_frame_new(ddir_label[ddir]);
704 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
706 main_vbox = gtk_vbox_new(FALSE, 3);
707 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
709 box = gtk_hbox_new(FALSE, 3);
710 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
712 label = new_info_label_in_frame(box, "IO");
713 gtk_label_set_text(GTK_LABEL(label), io_p);
714 label = new_info_label_in_frame(box, "Bandwidth");
715 gtk_label_set_text(GTK_LABEL(label), bw_p);
716 label = new_info_label_in_frame(box, "IOPS");
717 gtk_label_set_text(GTK_LABEL(label), iops_p);
718 label = new_info_label_in_frame(box, "Runtime (msec)");
719 label_set_int_value(label, ts->runtime[ddir]);
721 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
722 double p_of_agg = 100.0;
723 const char *bw_str = "KB";
727 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
728 if (p_of_agg > 100.0)
732 if (mean[0] > 999999.9) {
740 sprintf(tmp, "Bandwidth (%s)", bw_str);
741 frame = gtk_frame_new(tmp);
742 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
744 box = gtk_hbox_new(FALSE, 3);
745 gtk_container_add(GTK_CONTAINER(frame), box);
747 label = new_info_label_in_frame(box, "Minimum");
748 label_set_int_value(label, min[0]);
749 label = new_info_label_in_frame(box, "Maximum");
750 label_set_int_value(label, max[0]);
751 label = new_info_label_in_frame(box, "Percentage of jobs");
752 sprintf(tmp, "%3.2f%%", p_of_agg);
753 gtk_label_set_text(GTK_LABEL(label), tmp);
754 label = new_info_label_in_frame(box, "Average");
755 sprintf(tmp, "%5.02f", mean[0]);
756 gtk_label_set_text(GTK_LABEL(label), tmp);
757 label = new_info_label_in_frame(box, "Standard deviation");
758 sprintf(tmp, "%5.02f", dev[0]);
759 gtk_label_set_text(GTK_LABEL(label), tmp);
762 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
764 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
766 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
770 frame = gtk_frame_new("Latency");
771 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
773 vbox = gtk_vbox_new(FALSE, 3);
774 gtk_container_add(GTK_CONTAINER(frame), vbox);
776 if (flags & GFIO_SLAT)
777 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
778 if (flags & GFIO_CLAT)
779 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
780 if (flags & GFIO_LAT)
781 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
784 if (ts->clat_percentiles)
785 gfio_show_clat_percentiles(main_vbox, ts, ddir);
793 static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
796 GtkWidget *tree_view;
797 GtkTreeSelection *selection;
804 * Check if all are empty, in which case don't bother
806 for (i = 0, skipped = 0; i < num; i++)
813 types = malloc(num * sizeof(GType));
815 for (i = 0; i < num; i++)
816 types[i] = G_TYPE_STRING;
818 model = gtk_list_store_newv(num, types);
822 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
823 gtk_widget_set_can_focus(tree_view, FALSE);
825 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
826 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
828 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
829 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
831 for (i = 0; i < num; i++)
832 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
834 gtk_list_store_append(model, &iter);
836 for (i = 0; i < num; i++) {
840 sprintf(fbuf, "0.00");
842 sprintf(fbuf, "%3.2f%%", lat[i]);
844 gtk_list_store_set(model, &iter, i, fbuf, -1);
850 static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
852 GtkWidget *box, *frame, *tree_view;
853 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
854 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
855 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
856 "250", "500", "750", "1000", };
857 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
858 "250", "500", "750", "1000", "2000",
861 stat_calc_lat_u(ts, io_u_lat_u);
862 stat_calc_lat_m(ts, io_u_lat_m);
864 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
866 frame = gtk_frame_new("Latency buckets (usec)");
867 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
869 box = gtk_hbox_new(FALSE, 3);
870 gtk_container_add(GTK_CONTAINER(frame), box);
871 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
874 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
876 frame = gtk_frame_new("Latency buckets (msec)");
877 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
879 box = gtk_hbox_new(FALSE, 3);
880 gtk_container_add(GTK_CONTAINER(frame), box);
881 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
885 static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
887 GtkWidget *box, *frame, *entry;
888 double usr_cpu, sys_cpu;
889 unsigned long runtime;
892 runtime = ts->total_run_time;
894 double runt = (double) runtime;
896 usr_cpu = (double) ts->usr_time * 100 / runt;
897 sys_cpu = (double) ts->sys_time * 100 / runt;
903 frame = gtk_frame_new("OS resources");
904 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
906 box = gtk_hbox_new(FALSE, 3);
907 gtk_container_add(GTK_CONTAINER(frame), box);
909 entry = new_info_entry_in_frame(box, "User CPU");
910 sprintf(tmp, "%3.2f%%", usr_cpu);
911 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
912 entry = new_info_entry_in_frame(box, "System CPU");
913 sprintf(tmp, "%3.2f%%", sys_cpu);
914 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
915 entry = new_info_entry_in_frame(box, "Context switches");
916 entry_set_int_value(entry, ts->ctx);
917 entry = new_info_entry_in_frame(box, "Major faults");
918 entry_set_int_value(entry, ts->majf);
919 entry = new_info_entry_in_frame(box, "Minor faults");
920 entry_set_int_value(entry, ts->minf);
922 static void gfio_add_sc_depths_tree(GtkListStore *model,
923 struct thread_stat *ts, unsigned int len,
926 double io_u_dist[FIO_IO_U_MAP_NR];
928 /* Bits 0, and 3-8 */
929 const int add_mask = 0x1f9;
933 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
935 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
937 gtk_list_store_append(model, &iter);
939 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
941 for (i = 1, j = 0; i < len; i++) {
944 if (!(add_mask & (1UL << (i - 1))))
945 sprintf(fbuf, "0.0%%");
947 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
951 gtk_list_store_set(model, &iter, i, fbuf, -1);
956 static void gfio_add_total_depths_tree(GtkListStore *model,
957 struct thread_stat *ts, unsigned int len)
959 double io_u_dist[FIO_IO_U_MAP_NR];
961 /* Bits 1-6, and 8 */
962 const int add_mask = 0x17e;
965 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
967 gtk_list_store_append(model, &iter);
969 gtk_list_store_set(model, &iter, 0, "Total", -1);
971 for (i = 1, j = 0; i < len; i++) {
974 if (!(add_mask & (1UL << (i - 1))))
975 sprintf(fbuf, "0.0%%");
977 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
981 gtk_list_store_set(model, &iter, i, fbuf, -1);
986 static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
988 GtkWidget *frame, *box, *tree_view;
989 GtkTreeSelection *selection;
991 GType types[FIO_IO_U_MAP_NR + 1];
994 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
996 frame = gtk_frame_new("IO depths");
997 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
999 box = gtk_hbox_new(FALSE, 3);
1000 gtk_container_add(GTK_CONTAINER(frame), box);
1002 for (i = 0; i < NR_LABELS; i++)
1003 types[i] = G_TYPE_STRING;
1005 model = gtk_list_store_newv(NR_LABELS, types);
1007 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
1008 gtk_widget_set_can_focus(tree_view, FALSE);
1010 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
1011 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
1013 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
1014 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
1016 for (i = 0; i < NR_LABELS; i++)
1017 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
1019 gfio_add_total_depths_tree(model, ts, NR_LABELS);
1020 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
1021 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
1023 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
1026 static gboolean results_window_delete(GtkWidget *w, gpointer data)
1028 struct gui_entry *ge = (struct gui_entry *) data;
1030 gtk_widget_destroy(w);
1031 ge->results_window = NULL;
1032 ge->results_notebook = NULL;
1036 static void results_close(GtkWidget *w, gpointer *data)
1038 struct gui_entry *ge = (struct gui_entry *) data;
1040 gtk_widget_destroy(ge->results_window);
1043 static GtkActionEntry results_menu_items[] = {
1044 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1045 { "GraphMenuAction", GTK_STOCK_FILE, "Graph", NULL, NULL, NULL},
1046 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(results_close) },
1048 static gint results_nmenu_items = sizeof(results_menu_items) / sizeof(results_menu_items[0]);
1050 static const gchar *results_ui_string = " \
1052 <menubar name=\"MainMenu\"> \
1053 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1054 <menuitem name=\"Close\" action=\"CloseFile\" /> \
1056 <menu name=\"GraphMenu\" action=\"GraphMenuAction\"> \
1062 static GtkWidget *get_results_menubar(GtkWidget *window, struct gui_entry *ge)
1064 GtkActionGroup *action_group;
1068 ge->results_uimanager = gtk_ui_manager_new();
1070 action_group = gtk_action_group_new("ResultsMenu");
1071 gtk_action_group_add_actions(action_group, results_menu_items, results_nmenu_items, ge);
1073 gtk_ui_manager_insert_action_group(ge->results_uimanager, action_group, 0);
1074 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ge->results_uimanager), results_ui_string, -1, &error);
1076 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ge->results_uimanager));
1078 widget = gtk_ui_manager_get_widget(ge->results_uimanager, "/MainMenu");
1082 static GtkWidget *get_results_window(struct gui_entry *ge)
1084 GtkWidget *win, *notebook, *vbox;
1086 if (ge->results_window)
1087 return ge->results_notebook;
1089 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1090 gtk_window_set_title(GTK_WINDOW(win), "Results");
1091 gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768);
1092 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
1093 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
1095 vbox = gtk_vbox_new(FALSE, 0);
1096 gtk_container_add(GTK_CONTAINER(win), vbox);
1098 ge->results_menu = get_results_menubar(win, ge);
1099 gtk_box_pack_start(GTK_BOX(vbox), ge->results_menu, FALSE, FALSE, 0);
1101 notebook = gtk_notebook_new();
1102 gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
1103 gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
1104 gtk_container_add(GTK_CONTAINER(vbox), notebook);
1106 ge->results_window = win;
1107 ge->results_notebook = notebook;
1108 return ge->results_notebook;
1111 static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
1112 struct group_run_stats *rs)
1114 GtkWidget *res_win, *box, *vbox, *entry, *scroll;
1115 struct gfio_client *gc = client->client_data;
1117 gdk_threads_enter();
1119 res_win = get_results_window(gc->ge);
1121 scroll = gtk_scrolled_window_new(NULL, NULL);
1122 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1123 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1125 vbox = gtk_vbox_new(FALSE, 3);
1127 box = gtk_hbox_new(FALSE, 0);
1128 gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5);
1130 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
1132 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name));
1134 gc->results_widget = vbox;
1136 entry = new_info_entry_in_frame(box, "Name");
1137 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
1138 if (strlen(ts->description)) {
1139 entry = new_info_entry_in_frame(box, "Description");
1140 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
1142 entry = new_info_entry_in_frame(box, "Group ID");
1143 entry_set_int_value(entry, ts->groupid);
1144 entry = new_info_entry_in_frame(box, "Jobs");
1145 entry_set_int_value(entry, ts->members);
1146 gc->err_entry = entry = new_info_entry_in_frame(box, "Error");
1147 entry_set_int_value(entry, ts->error);
1148 entry = new_info_entry_in_frame(box, "PID");
1149 entry_set_int_value(entry, ts->pid);
1151 if (ts->io_bytes[DDIR_READ])
1152 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
1153 if (ts->io_bytes[DDIR_WRITE])
1154 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
1156 gfio_show_latency_buckets(vbox, ts);
1157 gfio_show_cpu_usage(vbox, ts);
1158 gfio_show_io_depths(vbox, ts);
1160 gtk_widget_show_all(gc->ge->results_window);
1161 gdk_threads_leave();
1164 static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
1166 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
1167 struct gui *ui = &main_ui;
1171 char tmp[64], timebuf[80];
1174 tm = localtime(&sec);
1175 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
1176 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
1178 gdk_threads_enter();
1180 gtk_list_store_append(ui->log_model, &iter);
1181 gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1);
1182 gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1);
1183 gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1);
1184 gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1);
1186 if (p->level == FIO_LOG_ERR)
1187 view_log(NULL, (gpointer) ui);
1189 gdk_threads_leave();
1192 static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
1194 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
1195 struct gfio_client *gc = client->client_data;
1196 GtkWidget *box, *frame, *entry, *vbox;
1200 gdk_threads_enter();
1202 if (!gc->results_widget)
1205 if (!gc->disk_util_frame) {
1206 gc->disk_util_frame = gtk_frame_new("Disk utilization");
1207 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
1210 vbox = gtk_vbox_new(FALSE, 3);
1211 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
1213 frame = gtk_frame_new((char *) p->dus.name);
1214 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
1216 box = gtk_vbox_new(FALSE, 3);
1217 gtk_container_add(GTK_CONTAINER(frame), box);
1219 frame = gtk_frame_new("Read");
1220 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1221 vbox = gtk_hbox_new(TRUE, 3);
1222 gtk_container_add(GTK_CONTAINER(frame), vbox);
1223 entry = new_info_entry_in_frame(vbox, "IOs");
1224 entry_set_int_value(entry, p->dus.ios[0]);
1225 entry = new_info_entry_in_frame(vbox, "Merges");
1226 entry_set_int_value(entry, p->dus.merges[0]);
1227 entry = new_info_entry_in_frame(vbox, "Sectors");
1228 entry_set_int_value(entry, p->dus.sectors[0]);
1229 entry = new_info_entry_in_frame(vbox, "Ticks");
1230 entry_set_int_value(entry, p->dus.ticks[0]);
1232 frame = gtk_frame_new("Write");
1233 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1234 vbox = gtk_hbox_new(TRUE, 3);
1235 gtk_container_add(GTK_CONTAINER(frame), vbox);
1236 entry = new_info_entry_in_frame(vbox, "IOs");
1237 entry_set_int_value(entry, p->dus.ios[1]);
1238 entry = new_info_entry_in_frame(vbox, "Merges");
1239 entry_set_int_value(entry, p->dus.merges[1]);
1240 entry = new_info_entry_in_frame(vbox, "Sectors");
1241 entry_set_int_value(entry, p->dus.sectors[1]);
1242 entry = new_info_entry_in_frame(vbox, "Ticks");
1243 entry_set_int_value(entry, p->dus.ticks[1]);
1245 frame = gtk_frame_new("Shared");
1246 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1247 vbox = gtk_hbox_new(TRUE, 3);
1248 gtk_container_add(GTK_CONTAINER(frame), vbox);
1249 entry = new_info_entry_in_frame(vbox, "IO ticks");
1250 entry_set_int_value(entry, p->dus.io_ticks);
1251 entry = new_info_entry_in_frame(vbox, "Time in queue");
1252 entry_set_int_value(entry, p->dus.time_in_queue);
1256 util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec;
1260 sprintf(tmp, "%3.2f%%", util);
1261 entry = new_info_entry_in_frame(vbox, "Disk utilization");
1262 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
1264 gtk_widget_show_all(gc->results_widget);
1266 gdk_threads_leave();
1269 extern int sum_stat_clients;
1270 extern struct thread_stat client_ts;
1271 extern struct group_run_stats client_gs;
1273 static int sum_stat_nr;
1275 static void gfio_thread_status_op(struct fio_client *client,
1276 struct fio_net_cmd *cmd)
1278 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
1280 gfio_display_ts(client, &p->ts, &p->rs);
1282 if (sum_stat_clients == 1)
1285 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
1286 sum_group_stats(&client_gs, &p->rs);
1288 client_ts.members++;
1289 client_ts.groupid = p->ts.groupid;
1291 if (++sum_stat_nr == sum_stat_clients) {
1292 strcpy(client_ts.name, "All clients");
1293 gfio_display_ts(client, &client_ts, &client_gs);
1297 static void gfio_group_stats_op(struct fio_client *client,
1298 struct fio_net_cmd *cmd)
1300 /* We're ignoring group stats for now */
1303 static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
1306 struct gfio_graphs *g = data;
1308 graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height);
1309 graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0);
1310 graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height);
1311 graph_set_position(g->bandwidth_graph, 0, 0);
1315 static void draw_graph(struct graph *g, cairo_t *cr)
1317 line_graph_draw(g, cr);
1321 static gboolean graph_tooltip(GtkWidget *w, gint x, gint y,
1322 gboolean keyboard_mode, GtkTooltip *tooltip,
1325 struct gfio_graphs *g = data;
1326 const char *text = NULL;
1328 if (graph_contains_xy(g->iops_graph, x, y))
1329 text = graph_find_tooltip(g->iops_graph, x, y);
1330 else if (graph_contains_xy(g->bandwidth_graph, x, y))
1331 text = graph_find_tooltip(g->bandwidth_graph, x, y);
1334 gtk_tooltip_set_text(tooltip, text);
1341 static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1343 struct gfio_graphs *g = p;
1346 cr = gdk_cairo_create(w->window);
1348 if (graph_has_tooltips(g->iops_graph) ||
1349 graph_has_tooltips(g->bandwidth_graph)) {
1350 g_object_set(w, "has-tooltip", TRUE, NULL);
1351 g_signal_connect(w, "query-tooltip", G_CALLBACK(graph_tooltip), g);
1354 cairo_set_source_rgb(cr, 0, 0, 0);
1355 draw_graph(g->iops_graph, cr);
1356 draw_graph(g->bandwidth_graph, cr);
1363 * Client specific ETA
1365 static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je)
1367 struct gfio_client *gc = client->client_data;
1368 struct gui_entry *ge = gc->ge;
1369 static int eta_good;
1376 gdk_threads_enter();
1381 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1382 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1383 eta_to_str(eta_str, je->eta_sec);
1386 sprintf(tmp, "%u", je->nr_running);
1387 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), tmp);
1388 sprintf(tmp, "%u", je->files_open);
1389 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), tmp);
1392 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1393 if (je->m_rate || je->t_rate) {
1396 mr = num2str(je->m_rate, 4, 0, i2p);
1397 tr = num2str(je->t_rate, 4, 0, i2p);
1398 gtk_entry_set_text(GTK_ENTRY(ge->eta);
1399 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1402 } else if (je->m_iops || je->t_iops)
1403 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1405 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_bw), "---");
1406 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---");
1407 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---");
1408 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_iops), "---");
1411 if (je->eta_sec != INT_MAX && je->nr_running) {
1415 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1416 strcpy(output, "-.-% done");
1420 sprintf(output, "%3.1f%% done", perc);
1423 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1424 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1426 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1427 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1429 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), rate_str[0]);
1430 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]);
1431 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]);
1432 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]);
1434 graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]);
1435 graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]);
1436 graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]);
1437 graph_add_xy_data(ge->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]);
1446 char *dst = output + strlen(output);
1448 sprintf(dst, " - %s", eta_str);
1451 gfio_update_thread_status(ge, output, perc);
1452 gdk_threads_leave();
1456 * Update ETA in main window for all clients
1458 static void gfio_update_all_eta(struct jobs_eta *je)
1460 struct gui *ui = &main_ui;
1461 static int eta_good;
1467 gdk_threads_enter();
1472 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1473 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1474 eta_to_str(eta_str, je->eta_sec);
1478 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1479 if (je->m_rate || je->t_rate) {
1482 mr = num2str(je->m_rate, 4, 0, i2p);
1483 tr = num2str(je->t_rate, 4, 0, i2p);
1484 gtk_entry_set_text(GTK_ENTRY(ui->eta);
1485 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1488 } else if (je->m_iops || je->t_iops)
1489 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1491 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_bw), "---");
1492 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_iops), "---");
1493 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_bw), "---");
1494 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_iops), "---");
1497 entry_set_int_value(ui->eta.jobs, je->nr_running);
1499 if (je->eta_sec != INT_MAX && je->nr_running) {
1503 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1504 strcpy(output, "-.-% done");
1508 sprintf(output, "%3.1f%% done", perc);
1511 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1512 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1514 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1515 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1517 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), rate_str[0]);
1518 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), iops_str[0]);
1519 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), rate_str[1]);
1520 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), iops_str[1]);
1522 graph_add_xy_data(ui->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0], iops_str[0]);
1523 graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1], iops_str[1]);
1524 graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0], rate_str[0]);
1525 graph_add_xy_data(ui->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1], rate_str[1]);
1534 char *dst = output + strlen(output);
1536 sprintf(dst, " - %s", eta_str);
1539 gfio_update_thread_status_all(output, perc);
1540 gdk_threads_leave();
1543 static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1545 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
1546 struct gfio_client *gc = client->client_data;
1547 struct gui_entry *ge = gc->ge;
1548 const char *os, *arch;
1551 os = fio_get_os_string(probe->os);
1555 arch = fio_get_arch_string(probe->arch);
1560 client->name = strdup((char *) probe->hostname);
1562 gdk_threads_enter();
1564 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname);
1565 gtk_label_set_text(GTK_LABEL(ge->probe.os), os);
1566 gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch);
1567 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
1568 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf);
1570 gfio_set_state(ge, GE_STATE_CONNECTED);
1572 gdk_threads_leave();
1575 static void gfio_update_thread_status(struct gui_entry *ge,
1576 char *status_message, double perc)
1578 static char message[100];
1579 const char *m = message;
1581 strncpy(message, status_message, sizeof(message) - 1);
1582 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m);
1583 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0);
1584 gtk_widget_queue_draw(main_ui.window);
1587 static void gfio_update_thread_status_all(char *status_message, double perc)
1589 struct gui *ui = &main_ui;
1590 static char message[100];
1591 const char *m = message;
1593 strncpy(message, status_message, sizeof(message) - 1);
1594 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m);
1595 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0);
1596 gtk_widget_queue_draw(ui->window);
1599 static void gfio_quit_op(struct fio_client *client, struct fio_net_cmd *cmd)
1601 struct gfio_client *gc = client->client_data;
1603 gdk_threads_enter();
1604 gfio_set_state(gc->ge, GE_STATE_NEW);
1605 gdk_threads_leave();
1608 static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1610 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
1611 struct gfio_client *gc = client->client_data;
1612 struct thread_options *o = &gc->o;
1613 struct gui_entry *ge = gc->ge;
1616 convert_thread_options_to_cpu(o, &p->top);
1618 gdk_threads_enter();
1620 gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name);
1622 gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name);
1623 gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0);
1625 multitext_add_entry(&ge->eta.iotype, ddir_str(o->td_ddir));
1626 multitext_add_entry(&ge->eta.ioengine, (const char *) o->ioengine);
1628 sprintf(tmp, "%u", o->iodepth);
1629 multitext_add_entry(&ge->eta.iodepth, tmp);
1631 multitext_set_entry(&ge->eta.iotype, 0);
1632 multitext_set_entry(&ge->eta.ioengine, 0);
1633 multitext_set_entry(&ge->eta.iodepth, 0);
1637 gfio_set_state(ge, GE_STATE_JOB_SENT);
1639 gdk_threads_leave();
1642 static void gfio_client_timed_out(struct fio_client *client)
1644 struct gfio_client *gc = client->client_data;
1647 gdk_threads_enter();
1649 gfio_set_state(gc->ge, GE_STATE_NEW);
1650 clear_ge_ui_info(gc->ge);
1652 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1653 show_info_dialog(gc->ge->ui, "Network timeout", buf);
1655 gdk_threads_leave();
1658 static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd)
1660 struct gfio_client *gc = client->client_data;
1662 gdk_threads_enter();
1664 gfio_set_state(gc->ge, GE_STATE_JOB_DONE);
1667 entry_set_int_value(gc->err_entry, client->error);
1669 gdk_threads_leave();
1672 static void gfio_client_start(struct fio_client *client, struct fio_net_cmd *cmd)
1674 struct gfio_client *gc = client->client_data;
1676 gdk_threads_enter();
1677 gfio_set_state(gc->ge, GE_STATE_JOB_STARTED);
1678 gdk_threads_leave();
1681 static void gfio_client_job_start(struct fio_client *client, struct fio_net_cmd *cmd)
1683 struct gfio_client *gc = client->client_data;
1685 gdk_threads_enter();
1686 gfio_set_state(gc->ge, GE_STATE_JOB_RUNNING);
1687 gdk_threads_leave();
1690 static void gfio_client_iolog(struct fio_client *client, struct cmd_iolog_pdu *pdu)
1695 struct client_ops gfio_client_ops = {
1696 .text = gfio_text_op,
1697 .disk_util = gfio_disk_util_op,
1698 .thread_status = gfio_thread_status_op,
1699 .group_stats = gfio_group_stats_op,
1700 .jobs_eta = gfio_update_client_eta,
1701 .eta = gfio_update_all_eta,
1702 .probe = gfio_probe_op,
1703 .quit = gfio_quit_op,
1704 .add_job = gfio_add_job_op,
1705 .timed_out = gfio_client_timed_out,
1706 .stop = gfio_client_stop,
1707 .start = gfio_client_start,
1708 .job_start = gfio_client_job_start,
1709 .iolog = gfio_client_iolog,
1710 .eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
1711 .stay_connected = 1,
1712 .client_type = FIO_CLIENT_TYPE_GUI,
1716 * FIXME: need more handling here
1718 static void ge_destroy(struct gui_entry *ge)
1720 struct gfio_client *gc = ge->client;
1722 if (gc && gc->client) {
1723 if (ge->state >= GE_STATE_CONNECTED)
1724 fio_client_terminate(gc->client);
1726 fio_put_client(gc->client);
1729 flist_del(&ge->list);
1733 static void ge_widget_destroy(GtkWidget *w, gpointer data)
1737 static void gfio_quit(struct gui *ui)
1739 struct gui_entry *ge;
1741 while (!flist_empty(&ui->list)) {
1742 ge = flist_entry(ui->list.next, struct gui_entry, list);
1749 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1750 __attribute__((unused)) gpointer data)
1755 static void *job_thread(void *arg)
1757 struct gui *ui = arg;
1759 ui->handler_running = 1;
1760 fio_handle_clients(&gfio_client_ops);
1761 ui->handler_running = 0;
1765 static int send_job_files(struct gui_entry *ge)
1767 struct gfio_client *gc = ge->client;
1770 for (i = 0; i < ge->nr_job_files; i++) {
1771 ret = fio_client_send_ini(gc->client, ge->job_files[i]);
1775 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret));
1776 report_error(error);
1777 g_error_free(error);
1782 free(ge->job_files[i]);
1783 ge->job_files[i] = NULL;
1785 while (i < ge->nr_job_files) {
1786 free(ge->job_files[i]);
1787 ge->job_files[i] = NULL;
1791 free(ge->job_files);
1792 ge->job_files = NULL;
1793 ge->nr_job_files = 0;
1797 static void *server_thread(void *arg)
1800 gfio_server_running = 1;
1801 fio_start_server(NULL);
1802 gfio_server_running = 0;
1806 static void gfio_start_server(void)
1808 struct gui *ui = &main_ui;
1810 if (!gfio_server_running) {
1811 gfio_server_running = 1;
1812 pthread_create(&ui->server_t, NULL, server_thread, NULL);
1813 pthread_detach(ui->server_t);
1817 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
1820 struct gui_entry *ge = data;
1821 struct gfio_client *gc = ge->client;
1824 fio_start_client(gc->client);
1827 static void file_open(GtkWidget *w, gpointer data);
1829 static void connect_clicked(GtkWidget *widget, gpointer data)
1831 struct gui_entry *ge = data;
1832 struct gfio_client *gc = ge->client;
1834 if (ge->state == GE_STATE_NEW) {
1837 if (!ge->nr_job_files)
1838 file_open(widget, ge->ui);
1839 if (!ge->nr_job_files)
1842 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
1843 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
1844 ret = fio_client_connect(gc->client);
1846 if (!ge->ui->handler_running)
1847 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
1848 gfio_set_state(ge, GE_STATE_CONNECTED);
1852 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
1853 report_error(error);
1854 g_error_free(error);
1857 fio_client_terminate(gc->client);
1858 gfio_set_state(ge, GE_STATE_NEW);
1859 clear_ge_ui_info(ge);
1863 static void send_clicked(GtkWidget *widget, gpointer data)
1865 struct gui_entry *ge = data;
1867 if (send_job_files(ge)) {
1870 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);
1871 report_error(error);
1872 g_error_free(error);
1874 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
1878 static GtkWidget *add_button(GtkWidget *buttonbox,
1879 struct button_spec *buttonspec, gpointer data)
1881 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
1883 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
1884 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
1885 gtk_widget_set_tooltip_text(button, buttonspec->tooltiptext);
1886 gtk_widget_set_sensitive(button, !buttonspec->start_insensitive);
1891 static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
1896 for (i = 0; i < nbuttons; i++)
1897 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
1900 static void on_info_bar_response(GtkWidget *widget, gint response,
1903 struct gui *ui = &main_ui;
1905 if (response == GTK_RESPONSE_OK) {
1906 gtk_widget_destroy(widget);
1907 ui->error_info_bar = NULL;
1911 void report_error(GError *error)
1913 struct gui *ui = &main_ui;
1915 if (ui->error_info_bar == NULL) {
1916 ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1919 g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1920 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar),
1923 ui->error_label = gtk_label_new(error->message);
1924 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar));
1925 gtk_container_add(GTK_CONTAINER(container), ui->error_label);
1927 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0);
1928 gtk_widget_show_all(ui->vbox);
1931 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1932 gtk_label_set(GTK_LABEL(ui->error_label), buffer);
1936 struct connection_widgets
1943 static void hostname_cb(GtkEntry *entry, gpointer data)
1945 struct connection_widgets *cw = data;
1946 int uses_net = 0, is_localhost = 0;
1951 * Check whether to display the 'auto start backend' box
1952 * or not. Show it if we are a localhost and using network,
1953 * or using a socket.
1955 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1956 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1961 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1962 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1963 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1964 !strcmp(text, "ip6-loopback"))
1968 if (!uses_net || is_localhost) {
1969 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1970 gtk_widget_set_sensitive(cw->button, 1);
1972 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1973 gtk_widget_set_sensitive(cw->button, 0);
1977 static int get_connection_details(char **host, int *port, int *type,
1980 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1981 struct connection_widgets cw;
1984 dialog = gtk_dialog_new_with_buttons("Connection details",
1985 GTK_WINDOW(main_ui.window),
1986 GTK_DIALOG_DESTROY_WITH_PARENT,
1987 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1988 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1990 frame = gtk_frame_new("Hostname / socket name");
1991 /* gtk_dialog_get_content_area() is 2.14 and newer */
1992 vbox = GTK_DIALOG(dialog)->vbox;
1993 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1995 box = gtk_vbox_new(FALSE, 6);
1996 gtk_container_add(GTK_CONTAINER(frame), box);
1998 hbox = gtk_hbox_new(TRUE, 10);
1999 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
2000 cw.hentry = gtk_entry_new();
2001 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
2002 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
2004 frame = gtk_frame_new("Port");
2005 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2006 box = gtk_vbox_new(FALSE, 10);
2007 gtk_container_add(GTK_CONTAINER(frame), box);
2009 hbox = gtk_hbox_new(TRUE, 4);
2010 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
2011 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
2013 frame = gtk_frame_new("Type");
2014 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2015 box = gtk_vbox_new(FALSE, 10);
2016 gtk_container_add(GTK_CONTAINER(frame), box);
2018 hbox = gtk_hbox_new(TRUE, 4);
2019 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
2021 cw.combo = gtk_combo_box_new_text();
2022 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
2023 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
2024 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
2025 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
2027 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
2029 frame = gtk_frame_new("Options");
2030 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2031 box = gtk_vbox_new(FALSE, 10);
2032 gtk_container_add(GTK_CONTAINER(frame), box);
2034 hbox = gtk_hbox_new(TRUE, 4);
2035 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
2037 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
2038 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
2039 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.");
2040 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
2043 * Connect edit signal, so we can show/not-show the auto start button
2045 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
2046 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
2048 gtk_widget_show_all(dialog);
2050 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2051 gtk_widget_destroy(dialog);
2055 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
2056 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
2058 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
2059 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
2060 *type = Fio_client_ipv4;
2061 else if (!strncmp(typeentry, "IPv6", 4))
2062 *type = Fio_client_ipv6;
2064 *type = Fio_client_socket;
2067 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
2069 gtk_widget_destroy(dialog);
2073 static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
2075 struct gfio_client *gc;
2077 gc = malloc(sizeof(*gc));
2078 memset(gc, 0, sizeof(*gc));
2080 gc->client = fio_get_client(client);
2084 client->client_data = gc;
2087 static GtkWidget *new_client_page(struct gui_entry *ge);
2089 static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
2091 struct gui_entry *ge;
2093 ge = malloc(sizeof(*ge));
2094 memset(ge, 0, sizeof(*ge));
2095 ge->state = GE_STATE_NEW;
2096 INIT_FLIST_HEAD(&ge->list);
2097 flist_add_tail(&ge->list, &ui->list);
2102 static struct gui_entry *get_new_ge_with_tab(const char *name)
2104 struct gui_entry *ge;
2106 ge = alloc_new_gui_entry(&main_ui);
2108 ge->vbox = new_client_page(ge);
2109 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_widget_destroy), ge);
2111 ge->page_label = gtk_label_new(name);
2112 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label);
2114 gtk_widget_show_all(main_ui.window);
2118 static void file_new(GtkWidget *w, gpointer data)
2120 struct gui *ui = (struct gui *) data;
2121 struct gui_entry *ge;
2123 ge = get_new_ge_with_tab("Untitled");
2124 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
2128 * Return the 'ge' corresponding to the tab. If the active tab is the
2129 * main tab, open a new tab.
2131 static struct gui_entry *get_ge_from_page(gint cur_page, int *created)
2133 struct flist_head *entry;
2134 struct gui_entry *ge;
2139 return get_new_ge_with_tab("Untitled");
2145 flist_for_each(entry, &main_ui.list) {
2146 ge = flist_entry(entry, struct gui_entry, list);
2147 if (ge->page_num == cur_page)
2154 static struct gui_entry *get_ge_from_cur_tab(struct gui *ui)
2159 * Main tab is tab 0, so any current page other than 0 holds
2162 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
2164 return get_ge_from_page(cur_page, NULL);
2169 static void file_close(GtkWidget *w, gpointer data)
2171 struct gui *ui = (struct gui *) data;
2172 struct gui_entry *ge;
2175 * Can't close the main tab
2177 ge = get_ge_from_cur_tab(ui);
2179 gtk_widget_destroy(ge->vbox);
2183 if (!flist_empty(&ui->list)) {
2184 show_info_dialog(ui, "Error", "The main page view cannot be closed\n");
2191 static void file_add_recent(struct gui *ui, const gchar *uri)
2195 memset(&grd, 0, sizeof(grd));
2196 grd.display_name = strdup("gfio");
2197 grd.description = strdup("Fio job file");
2198 grd.mime_type = strdup(GFIO_MIME);
2199 grd.app_name = strdup(g_get_application_name());
2200 grd.app_exec = strdup("gfio %f/%u");
2202 gtk_recent_manager_add_full(ui->recentmanager, uri, &grd);
2205 static gchar *get_filename_from_uri(const gchar *uri)
2207 if (strncmp(uri, "file://", 7))
2210 return strdup(uri + 7);
2213 static int do_file_open(struct gui_entry *ge, const gchar *uri, char *host,
2216 struct fio_client *client;
2219 filename = get_filename_from_uri(uri);
2221 ge->job_files = realloc(ge->job_files, (ge->nr_job_files + 1) * sizeof(char *));
2222 ge->job_files[ge->nr_job_files] = strdup(filename);
2225 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
2229 error = g_error_new(g_quark_from_string("fio"), 1,
2230 "Failed to add client %s", host);
2231 report_error(error);
2232 g_error_free(error);
2236 gfio_client_added(ge, client);
2237 file_add_recent(ge->ui, uri);
2241 static int do_file_open_with_tab(struct gui *ui, const gchar *uri)
2243 int port, type, server_start;
2244 struct gui_entry *ge;
2247 int ret, ge_is_new = 0;
2250 * Creates new tab if current tab is the main window, or the
2251 * current tab already has a client.
2253 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
2254 ge = get_ge_from_page(cur_page, &ge_is_new);
2256 ge = get_new_ge_with_tab("Untitled");
2260 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
2262 if (get_connection_details(&host, &port, &type, &server_start)) {
2264 gtk_widget_destroy(ge->vbox);
2269 ret = do_file_open(ge, uri, host, type, port);
2275 gfio_start_server();
2278 gtk_widget_destroy(ge->vbox);
2284 static void recent_open(GtkAction *action, gpointer data)
2286 struct gui *ui = (struct gui *) data;
2287 GtkRecentInfo *info;
2290 info = g_object_get_data(G_OBJECT(action), "gtk-recent-info");
2291 uri = gtk_recent_info_get_uri(info);
2293 do_file_open_with_tab(ui, uri);
2296 static void file_open(GtkWidget *w, gpointer data)
2298 struct gui *ui = data;
2300 GSList *filenames, *fn_glist;
2301 GtkFileFilter *filter;
2303 dialog = gtk_file_chooser_dialog_new("Open File",
2304 GTK_WINDOW(ui->window),
2305 GTK_FILE_CHOOSER_ACTION_OPEN,
2306 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2307 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
2309 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
2311 filter = gtk_file_filter_new();
2312 gtk_file_filter_add_pattern(filter, "*.fio");
2313 gtk_file_filter_add_pattern(filter, "*.job");
2314 gtk_file_filter_add_pattern(filter, "*.ini");
2315 gtk_file_filter_add_mime_type(filter, GFIO_MIME);
2316 gtk_file_filter_set_name(filter, "Fio job file");
2317 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
2319 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2320 gtk_widget_destroy(dialog);
2324 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
2326 gtk_widget_destroy(dialog);
2328 filenames = fn_glist;
2329 while (filenames != NULL) {
2330 if (do_file_open_with_tab(ui, filenames->data))
2332 filenames = g_slist_next(filenames);
2335 g_slist_free(fn_glist);
2338 static void file_save(GtkWidget *w, gpointer data)
2340 struct gui *ui = data;
2343 dialog = gtk_file_chooser_dialog_new("Save File",
2344 GTK_WINDOW(ui->window),
2345 GTK_FILE_CHOOSER_ACTION_SAVE,
2346 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
2347 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
2350 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
2351 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
2353 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2356 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
2357 // save_job_file(filename);
2360 gtk_widget_destroy(dialog);
2363 static void view_log_destroy(GtkWidget *w, gpointer data)
2365 struct gui *ui = (struct gui *) data;
2367 gtk_widget_ref(ui->log_tree);
2368 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
2369 gtk_widget_destroy(w);
2370 ui->log_view = NULL;
2373 static void view_log(GtkWidget *w, gpointer data)
2375 GtkWidget *win, *scroll, *vbox, *box;
2376 struct gui *ui = (struct gui *) data;
2381 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2382 gtk_window_set_title(GTK_WINDOW(win), "Log");
2383 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
2385 scroll = gtk_scrolled_window_new(NULL, NULL);
2387 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
2389 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2391 box = gtk_hbox_new(TRUE, 0);
2392 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
2393 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
2394 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
2396 vbox = gtk_vbox_new(TRUE, 5);
2397 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
2399 gtk_container_add(GTK_CONTAINER(win), vbox);
2400 gtk_widget_show_all(win);
2403 static void connect_job_entry(GtkWidget *w, gpointer data)
2405 struct gui *ui = (struct gui *) data;
2406 struct gui_entry *ge;
2408 ge = get_ge_from_cur_tab(ui);
2410 connect_clicked(w, ge);
2413 static void send_job_entry(GtkWidget *w, gpointer data)
2415 struct gui *ui = (struct gui *) data;
2416 struct gui_entry *ge;
2418 ge = get_ge_from_cur_tab(ui);
2420 send_clicked(w, ge);
2424 static void edit_job_entry(GtkWidget *w, gpointer data)
2428 static void start_job_entry(GtkWidget *w, gpointer data)
2430 struct gui *ui = (struct gui *) data;
2431 struct gui_entry *ge;
2433 ge = get_ge_from_cur_tab(ui);
2435 start_job_clicked(w, ge);
2438 static void __update_graph_limits(struct gfio_graphs *g)
2440 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
2441 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
2444 static void update_graph_limits(void)
2446 struct flist_head *entry;
2447 struct gui_entry *ge;
2449 __update_graph_limits(&main_ui.graphs);
2451 flist_for_each(entry, &main_ui.list) {
2452 ge = flist_entry(entry, struct gui_entry, list);
2453 __update_graph_limits(&ge->graphs);
2457 static void preferences(GtkWidget *w, gpointer data)
2459 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
2460 GtkWidget *hbox, *spin, *entry, *spin_int;
2463 dialog = gtk_dialog_new_with_buttons("Preferences",
2464 GTK_WINDOW(main_ui.window),
2465 GTK_DIALOG_DESTROY_WITH_PARENT,
2466 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2467 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
2470 frame = gtk_frame_new("Graphing");
2471 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2472 vbox = gtk_vbox_new(FALSE, 6);
2473 gtk_container_add(GTK_CONTAINER(frame), vbox);
2475 hbox = gtk_hbox_new(FALSE, 5);
2476 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
2477 entry = gtk_label_new("Font face to use for graph labels");
2478 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
2480 font = gtk_font_button_new();
2481 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
2483 box = gtk_vbox_new(FALSE, 6);
2484 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2486 hbox = gtk_hbox_new(FALSE, 5);
2487 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
2488 entry = gtk_label_new("Maximum number of data points in graph (seconds)");
2489 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2491 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
2493 box = gtk_vbox_new(FALSE, 6);
2494 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2496 hbox = gtk_hbox_new(FALSE, 5);
2497 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
2498 entry = gtk_label_new("Client ETA request interval (msec)");
2499 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2501 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
2502 frame = gtk_frame_new("Debug logging");
2503 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2504 vbox = gtk_vbox_new(FALSE, 6);
2505 gtk_container_add(GTK_CONTAINER(frame), vbox);
2507 box = gtk_hbox_new(FALSE, 6);
2508 gtk_container_add(GTK_CONTAINER(vbox), box);
2510 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
2512 for (i = 0; i < FD_DEBUG_MAX; i++) {
2514 box = gtk_hbox_new(FALSE, 6);
2515 gtk_container_add(GTK_CONTAINER(vbox), box);
2519 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
2520 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
2521 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
2524 gtk_widget_show_all(dialog);
2526 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2527 gtk_widget_destroy(dialog);
2531 for (i = 0; i < FD_DEBUG_MAX; i++) {
2534 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
2536 fio_debug |= (1UL << i);
2539 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
2540 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
2541 update_graph_limits();
2542 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
2544 gtk_widget_destroy(dialog);
2547 static void about_dialog(GtkWidget *w, gpointer data)
2549 const char *authors[] = {
2550 "Jens Axboe <axboe@kernel.dk>",
2551 "Stephen Carmeron <stephenmcameron@gmail.com>",
2554 const char *license[] = {
2555 "Fio is free software; you can redistribute it and/or modify "
2556 "it under the terms of the GNU General Public License as published by "
2557 "the Free Software Foundation; either version 2 of the License, or "
2558 "(at your option) any later version.\n",
2559 "Fio is distributed in the hope that it will be useful, "
2560 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
2561 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
2562 "GNU General Public License for more details.\n",
2563 "You should have received a copy of the GNU General Public License "
2564 "along with Fio; if not, write to the Free Software Foundation, Inc., "
2565 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
2567 char *license_trans;
2569 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
2570 license[2], "\n", NULL);
2572 gtk_show_about_dialog(NULL,
2573 "program-name", "gfio",
2574 "comments", "Gtk2 UI for fio",
2575 "license", license_trans,
2576 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
2578 "version", fio_version_string,
2579 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
2580 "logo-icon-name", "fio",
2582 "wrap-license", TRUE,
2585 g_free(license_trans);
2588 static GtkActionEntry menu_items[] = {
2589 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
2590 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
2591 { "JobMenuAction", GTK_STOCK_FILE, "Job", NULL, NULL, NULL},
2592 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
2593 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
2594 { "CloseFile", GTK_STOCK_CLOSE, "Close", "<Control>W", NULL, G_CALLBACK(file_close) },
2595 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
2596 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
2597 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
2598 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
2599 { "ConnectJob", NULL, "Connect", "<Control>E", NULL, G_CALLBACK(connect_job_entry) },
2600 { "EditJob", NULL, "Edit job", "<Control>E", NULL, G_CALLBACK(edit_job_entry) },
2601 { "SendJob", NULL, "Send job", "<Control>X", NULL, G_CALLBACK(send_job_entry) },
2602 { "StartJob", NULL, "Start job", "<Control>L", NULL, G_CALLBACK(start_job_entry) },
2603 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
2604 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
2606 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
2608 static const gchar *ui_string = " \
2610 <menubar name=\"MainMenu\"> \
2611 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
2612 <menuitem name=\"New\" action=\"NewFile\" /> \
2613 <menuitem name=\"Close\" action=\"CloseFile\" /> \
2614 <separator name=\"Separator1\"/> \
2615 <menuitem name=\"Open\" action=\"OpenFile\" /> \
2616 <menuitem name=\"Save\" action=\"SaveFile\" /> \
2617 <separator name=\"Separator2\"/> \
2618 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
2619 <separator name=\"Separator3\"/> \
2620 <placeholder name=\"FileRecentFiles\"/> \
2621 <separator name=\"Separator4\"/> \
2622 <menuitem name=\"Quit\" action=\"Quit\" /> \
2624 <menu name=\"JobMenu\" action=\"JobMenuAction\"> \
2625 <menuitem name=\"Connect\" action=\"ConnectJob\" /> \
2626 <separator name=\"Separator5\"/> \
2627 <menuitem name=\"Edit job\" action=\"EditJob\" /> \
2628 <menuitem name=\"Send job\" action=\"SendJob\" /> \
2629 <separator name=\"Separator6\"/> \
2630 <menuitem name=\"Start job\" action=\"StartJob\" /> \
2632 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
2633 <menuitem name=\"Log\" action=\"ViewLog\" /> \
2635 <menu name=\"Help\" action=\"HelpMenuAction\"> \
2636 <menuitem name=\"About\" action=\"About\" /> \
2642 static void set_job_menu_visible(struct gui *ui, int visible)
2646 job = gtk_ui_manager_get_widget(ui->uimanager, "/MainMenu/JobMenu");
2647 gtk_widget_set_sensitive(job, visible);
2650 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
2653 GtkActionGroup *action_group;
2656 action_group = gtk_action_group_new("Menu");
2657 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
2659 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
2660 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
2662 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
2664 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
2667 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
2668 GtkWidget *vbox, GtkUIManager *ui_manager)
2670 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
2673 static void combo_entry_changed(GtkComboBox *box, gpointer data)
2675 struct gui_entry *ge = (struct gui_entry *) data;
2678 index = gtk_combo_box_get_active(box);
2680 multitext_set_entry(&ge->eta.iotype, index);
2681 multitext_set_entry(&ge->eta.ioengine, index);
2682 multitext_set_entry(&ge->eta.iodepth, index);
2685 static void combo_entry_destroy(GtkWidget *widget, gpointer data)
2687 struct gui_entry *ge = (struct gui_entry *) data;
2689 multitext_free(&ge->eta.iotype);
2690 multitext_free(&ge->eta.ioengine);
2691 multitext_free(&ge->eta.iodepth);
2694 static GtkWidget *new_client_page(struct gui_entry *ge)
2696 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
2697 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
2700 main_vbox = gtk_vbox_new(FALSE, 3);
2702 top_align = gtk_alignment_new(0, 0, 1, 0);
2703 top_vbox = gtk_vbox_new(FALSE, 3);
2704 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
2705 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
2707 probe = gtk_frame_new("Job");
2708 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
2709 probe_frame = gtk_vbox_new(FALSE, 3);
2710 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2712 probe_box = gtk_hbox_new(FALSE, 3);
2713 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2714 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
2715 ge->probe.os = new_info_label_in_frame(probe_box, "OS");
2716 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
2717 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
2719 probe_box = gtk_hbox_new(FALSE, 3);
2720 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2722 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
2723 g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge);
2724 g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge);
2725 ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO");
2726 ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine");
2727 ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth");
2728 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
2729 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
2731 probe_box = gtk_hbox_new(FALSE, 3);
2732 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2733 ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2734 ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2735 ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2736 ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
2739 * Only add this if we have a commit rate
2742 probe_box = gtk_hbox_new(FALSE, 3);
2743 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
2745 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2746 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2748 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2749 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2753 * Set up a drawing area and IOPS and bandwidth graphs
2755 gdk_color_parse("white", &white);
2756 ge->graphs.drawing_area = gtk_drawing_area_new();
2757 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
2758 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2759 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2760 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event",
2761 G_CALLBACK(on_expose_drawing_area), &ge->graphs);
2762 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
2763 G_CALLBACK(on_config_drawing_area), &ge->graphs);
2764 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2765 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2766 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2767 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
2768 ge->graphs.drawing_area);
2769 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window, TRUE, TRUE, 0);
2771 setup_graphs(&ge->graphs);
2774 * Set up alignments for widgets at the bottom of ui,
2775 * align bottom left, expand horizontally but not vertically
2777 bottom_align = gtk_alignment_new(0, 1, 1, 0);
2778 ge->buttonbox = gtk_hbox_new(FALSE, 0);
2779 gtk_container_add(GTK_CONTAINER(bottom_align), ge->buttonbox);
2780 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
2782 add_buttons(ge, buttonspeclist, ARRAYSIZE(buttonspeclist));
2785 * Set up thread status progress bar
2787 ge->thread_status_pb = gtk_progress_bar_new();
2788 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
2789 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
2790 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
2796 static GtkWidget *new_main_page(struct gui *ui)
2798 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
2799 GtkWidget *scrolled_window, *bottom_align, *top_align, *top_vbox;
2802 main_vbox = gtk_vbox_new(FALSE, 3);
2805 * Set up alignments for widgets at the top of ui,
2806 * align top left, expand horizontally but not vertically
2808 top_align = gtk_alignment_new(0, 0, 1, 0);
2809 top_vbox = gtk_vbox_new(FALSE, 0);
2810 gtk_container_add(GTK_CONTAINER(top_align), top_vbox);
2811 gtk_box_pack_start(GTK_BOX(main_vbox), top_align, FALSE, FALSE, 0);
2813 probe = gtk_frame_new("Run statistics");
2814 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
2815 probe_frame = gtk_vbox_new(FALSE, 3);
2816 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2818 probe_box = gtk_hbox_new(FALSE, 3);
2819 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2820 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
2821 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2822 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2823 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2824 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
2827 * Only add this if we have a commit rate
2830 probe_box = gtk_hbox_new(FALSE, 3);
2831 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
2833 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2834 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2836 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2837 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2841 * Set up a drawing area and IOPS and bandwidth graphs
2843 gdk_color_parse("white", &white);
2844 ui->graphs.drawing_area = gtk_drawing_area_new();
2845 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
2846 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2847 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2848 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event",
2849 G_CALLBACK(on_expose_drawing_area), &ui->graphs);
2850 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
2851 G_CALLBACK(on_config_drawing_area), &ui->graphs);
2852 scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2853 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
2854 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2855 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_window),
2856 ui->graphs.drawing_area);
2857 gtk_box_pack_start(GTK_BOX(main_vbox), scrolled_window,
2860 setup_graphs(&ui->graphs);
2863 * Set up alignments for widgets at the bottom of ui,
2864 * align bottom left, expand horizontally but not vertically
2866 bottom_align = gtk_alignment_new(0, 1, 1, 0);
2867 ui->buttonbox = gtk_hbox_new(FALSE, 0);
2868 gtk_container_add(GTK_CONTAINER(bottom_align), ui->buttonbox);
2869 gtk_box_pack_start(GTK_BOX(main_vbox), bottom_align, FALSE, FALSE, 0);
2872 * Set up thread status progress bar
2874 ui->thread_status_pb = gtk_progress_bar_new();
2875 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
2876 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
2877 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
2882 static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
2883 guint page, gpointer data)
2886 struct gui *ui = (struct gui *) data;
2887 struct gui_entry *ge;
2890 set_job_menu_visible(ui, 0);
2894 set_job_menu_visible(ui, 1);
2895 ge = get_ge_from_page(page, NULL);
2897 update_button_states(ui, ge);
2902 static gint compare_recent_items(GtkRecentInfo *a, GtkRecentInfo *b)
2904 time_t time_a = gtk_recent_info_get_visited(a);
2905 time_t time_b = gtk_recent_info_get_visited(b);
2907 return time_b - time_a;
2910 static void add_recent_file_items(struct gui *ui)
2912 const gchar *gfio = g_get_application_name();
2913 GList *items, *item;
2916 if (ui->recent_ui_id) {
2917 gtk_ui_manager_remove_ui(ui->uimanager, ui->recent_ui_id);
2918 gtk_ui_manager_ensure_update(ui->uimanager);
2920 ui->recent_ui_id = gtk_ui_manager_new_merge_id(ui->uimanager);
2922 if (ui->actiongroup) {
2923 gtk_ui_manager_remove_action_group(ui->uimanager, ui->actiongroup);
2924 g_object_unref(ui->actiongroup);
2926 ui->actiongroup = gtk_action_group_new("RecentFileActions");
2928 gtk_ui_manager_insert_action_group(ui->uimanager, ui->actiongroup, -1);
2930 items = gtk_recent_manager_get_items(ui->recentmanager);
2931 items = g_list_sort(items, (GCompareFunc) compare_recent_items);
2933 for (item = items; item && item->data; item = g_list_next(item)) {
2934 GtkRecentInfo *info = (GtkRecentInfo *) item->data;
2939 if (!gtk_recent_info_has_application(info, gfio))
2943 * We only support local files for now
2945 if (!gtk_recent_info_is_local(info) || !gtk_recent_info_exists(info))
2948 action_name = g_strdup_printf("RecentFile%u", i++);
2949 label = gtk_recent_info_get_display_name(info);
2951 action = g_object_new(GTK_TYPE_ACTION,
2952 "name", action_name,
2953 "label", label, NULL);
2955 g_object_set_data_full(G_OBJECT(action), "gtk-recent-info",
2956 gtk_recent_info_ref(info),
2957 (GDestroyNotify) gtk_recent_info_unref);
2960 g_signal_connect(action, "activate", G_CALLBACK(recent_open), ui);
2962 gtk_action_group_add_action(ui->actiongroup, action);
2963 g_object_unref(action);
2965 gtk_ui_manager_add_ui(ui->uimanager, ui->recent_ui_id,
2966 "/MainMenu/FileMenu/FileRecentFiles",
2968 GTK_UI_MANAGER_MENUITEM, FALSE);
2970 g_free(action_name);
2976 g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL);
2980 static void drag_and_drop_received(GtkWidget *widget, GdkDragContext *ctx,
2981 gint x, gint y, GtkSelectionData *data,
2982 guint info, guint time)
2984 struct gui *ui = &main_ui;
2989 source = gtk_drag_get_source_widget(ctx);
2990 if (source && widget == gtk_widget_get_toplevel(source)) {
2991 gtk_drag_finish(ctx, FALSE, FALSE, time);
2995 uris = gtk_selection_data_get_uris(data);
2997 gtk_drag_finish(ctx, FALSE, FALSE, time);
3003 if (do_file_open_with_tab(ui, uris[i]))
3008 gtk_drag_finish(ctx, TRUE, FALSE, time);
3012 static void init_ui(int *argc, char **argv[], struct gui *ui)
3014 GtkSettings *settings;
3017 /* Magical g*thread incantation, you just need this thread stuff.
3018 * Without it, the update that happens in gfio_update_thread_status
3019 * doesn't really happen in a timely fashion, you need expose events
3021 if (!g_thread_supported())
3022 g_thread_init(NULL);
3025 gtk_init(argc, argv);
3026 settings = gtk_settings_get_default();
3027 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
3030 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
3031 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
3032 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
3034 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
3035 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
3037 ui->vbox = gtk_vbox_new(FALSE, 0);
3038 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
3040 ui->uimanager = gtk_ui_manager_new();
3041 ui->menu = get_menubar_menu(ui->window, ui->uimanager, ui);
3042 gfio_ui_setup(settings, ui->menu, ui->vbox, ui->uimanager);
3044 ui->recentmanager = gtk_recent_manager_get_default();
3045 add_recent_file_items(ui);
3047 ui->notebook = gtk_notebook_new();
3048 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
3049 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
3050 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
3051 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
3053 vbox = new_main_page(ui);
3054 gtk_drag_dest_set(GTK_WIDGET(ui->window), GTK_DEST_DEFAULT_ALL, NULL, 0, GDK_ACTION_COPY);
3055 gtk_drag_dest_add_uri_targets(GTK_WIDGET(ui->window));
3056 g_signal_connect(ui->window, "drag-data-received", G_CALLBACK(drag_and_drop_received), ui);
3058 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
3060 gfio_ui_setup_log(ui);
3062 gtk_widget_show_all(ui->window);
3065 int main(int argc, char *argv[], char *envp[])
3067 if (initialize_fio(envp))
3069 if (fio_init_options())
3072 memset(&main_ui, 0, sizeof(main_ui));
3073 INIT_FLIST_HEAD(&main_ui.list);
3075 init_ui(&argc, &argv, &main_ui);
3077 gdk_threads_enter();
3079 gdk_threads_leave();