2 * gfio - gui front end for fio - the flexible io tester
4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
6 * The license below covers all files distributed with fio unless otherwise
7 * noted in the file itself.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 static void gfio_update_thread_status(char *status_message, double perc);
33 #define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
35 typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
37 static void connect_clicked(GtkWidget *widget, gpointer data);
38 static void start_job_clicked(GtkWidget *widget, gpointer data);
40 static struct button_spec {
41 const char *buttontext;
43 const char *tooltiptext;
44 const int start_insensitive;
45 } buttonspeclist[] = {
46 #define CONNECT_BUTTON 0
47 #define START_JOB_BUTTON 1
48 { "Connect", connect_clicked, "Connect to host", 0 },
51 "Send current fio job to fio server to be executed", 1 },
73 GtkWidget *write_iops;
83 GtkWidget *bottomalign;
84 GtkWidget *thread_status_pb;
86 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
87 GtkWidget *scrolled_window;
89 GtkWidget *error_info_bar;
90 GtkWidget *error_label;
92 struct probe_widget probe;
93 struct eta_widget eta;
97 struct fio_client *client;
102 static void clear_ui_info(struct gui *ui)
104 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
105 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
106 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
107 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
108 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
109 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
110 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
111 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
112 gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
113 gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
114 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
115 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
116 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
117 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
120 static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
122 GtkWidget *entry, *frame;
124 frame = gtk_frame_new(label);
125 entry = gtk_entry_new();
126 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
127 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
128 gtk_container_add(GTK_CONTAINER(frame), entry);
133 static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
135 GtkWidget *label_widget;
138 frame = gtk_frame_new(label);
139 label_widget = gtk_label_new(NULL);
140 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
141 gtk_container_add(GTK_CONTAINER(frame), label_widget);
146 static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
148 GtkWidget *button, *box;
150 box = gtk_hbox_new(FALSE, 3);
151 gtk_container_add(GTK_CONTAINER(hbox), box);
153 button = gtk_spin_button_new_with_range(min, max, 1.0);
154 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
156 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
157 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
162 static void gfio_set_connected(struct gui *ui, int connected)
165 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
167 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
170 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
171 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
175 static void label_set_int_value(GtkWidget *entry, unsigned int val)
179 sprintf(tmp, "%u", val);
180 gtk_label_set_text(GTK_LABEL(entry), tmp);
183 static void entry_set_int_value(GtkWidget *entry, unsigned int val)
187 sprintf(tmp, "%u", val);
188 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
192 #define ALIGN_RIGHT 2
196 GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
198 GtkCellRenderer *renderer;
199 GtkTreeViewColumn *col;
200 double xalign = 0.0; /* left as default */
201 PangoAlignment align;
204 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
205 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
207 visible = !(flags & INVISIBLE);
209 renderer = gtk_cell_renderer_text_new();
210 col = gtk_tree_view_column_new();
212 gtk_tree_view_column_set_title(col, title);
213 if (!(flags & UNSORTABLE))
214 gtk_tree_view_column_set_sort_column_id(col, index);
215 gtk_tree_view_column_set_resizable(col, TRUE);
216 gtk_tree_view_column_pack_start(col, renderer, TRUE);
217 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
218 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
220 case PANGO_ALIGN_LEFT:
223 case PANGO_ALIGN_CENTER:
226 case PANGO_ALIGN_RIGHT:
230 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
231 gtk_tree_view_column_set_visible(col, visible);
232 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
236 static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
242 GType types[FIO_IO_U_LIST_MAX_LEN];
243 GtkWidget *tree_view;
244 GtkTreeSelection *selection;
249 for (i = 0; i < len; i++)
250 types[i] = G_TYPE_INT;
252 model = gtk_list_store_newv(len, types);
254 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
255 gtk_widget_set_can_focus(tree_view, FALSE);
257 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
258 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
260 for (i = 0; i < len; i++) {
263 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
264 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
267 gtk_list_store_append(model, &iter);
269 for (i = 0; i < len; i++)
270 gtk_list_store_set(model, &iter, i, ovals[i], -1);
275 static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
278 unsigned int *io_u_plat = ts->io_u_plat[ddir];
279 unsigned long nr = ts->clat_stat[ddir].samples;
280 fio_fp64_t *plist = ts->percentile_list;
281 unsigned int *ovals, len, minv, maxv, scale_down;
283 GtkWidget *tree_view, *frame, *hbox;
286 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
291 * We default to usecs, but if the value range is such that we
292 * should scale down to msecs, do that.
294 if (minv > 2000 && maxv > 99999) {
302 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
304 sprintf(tmp, "Completion percentiles (%s)", base);
305 frame = gtk_frame_new(tmp);
306 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
308 hbox = gtk_hbox_new(FALSE, 3);
309 gtk_container_add(GTK_CONTAINER(frame), hbox);
311 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
317 static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
318 unsigned long max, double mean, double dev)
320 const char *base = "(usec)";
321 GtkWidget *hbox, *label, *frame;
325 if (!usec_to_msec(&min, &max, &mean, &dev))
328 minp = num2str(min, 6, 1, 0);
329 maxp = num2str(max, 6, 1, 0);
331 sprintf(tmp, "%s %s", name, base);
332 frame = gtk_frame_new(tmp);
333 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
335 hbox = gtk_hbox_new(FALSE, 3);
336 gtk_container_add(GTK_CONTAINER(frame), hbox);
338 label = new_info_label_in_frame(hbox, "Minimum");
339 gtk_label_set_text(GTK_LABEL(label), minp);
340 label = new_info_label_in_frame(hbox, "Maximum");
341 gtk_label_set_text(GTK_LABEL(label), maxp);
342 label = new_info_label_in_frame(hbox, "Average");
343 sprintf(tmp, "%5.02f", mean);
344 gtk_label_set_text(GTK_LABEL(label), tmp);
345 label = new_info_label_in_frame(hbox, "Standard deviation");
346 sprintf(tmp, "%5.02f", dev);
347 gtk_label_set_text(GTK_LABEL(label), tmp);
358 static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
359 struct thread_stat *ts, int ddir)
361 const char *ddir_label[2] = { "Read", "Write" };
362 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
363 unsigned long min, max, runt;
364 unsigned long long bw, iops;
365 unsigned int flags = 0;
367 char *io_p, *bw_p, *iops_p;
370 if (!ts->runtime[ddir])
373 i2p = is_power_of_2(rs->kb_base);
374 runt = ts->runtime[ddir];
376 bw = (1000 * ts->io_bytes[ddir]) / runt;
377 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
378 bw_p = num2str(bw, 6, 1, i2p);
380 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
381 iops_p = num2str(iops, 6, 1, 0);
383 box = gtk_hbox_new(FALSE, 3);
384 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
386 frame = gtk_frame_new(ddir_label[ddir]);
387 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
389 main_vbox = gtk_vbox_new(FALSE, 3);
390 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
392 box = gtk_hbox_new(FALSE, 3);
393 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
395 label = new_info_label_in_frame(box, "IO");
396 gtk_label_set_text(GTK_LABEL(label), io_p);
397 label = new_info_label_in_frame(box, "Bandwidth");
398 gtk_label_set_text(GTK_LABEL(label), bw_p);
399 label = new_info_label_in_frame(box, "IOPS");
400 gtk_label_set_text(GTK_LABEL(label), iops_p);
401 label = new_info_label_in_frame(box, "Runtime (msec)");
402 label_set_int_value(label, ts->runtime[ddir]);
404 if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev))
406 if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev))
408 if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev))
412 frame = gtk_frame_new("Latency");
413 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
415 vbox = gtk_vbox_new(FALSE, 3);
416 gtk_container_add(GTK_CONTAINER(frame), vbox);
418 if (flags & GFIO_SLAT)
419 gfio_show_lat(vbox, "Submission latency", min, max, mean, dev);
420 if (flags & GFIO_CLAT)
421 gfio_show_lat(vbox, "Completion latency", min, max, mean, dev);
422 if (flags & GFIO_LAT)
423 gfio_show_lat(vbox, "Total latency", min, max, mean, dev);
426 if (ts->clat_percentiles)
427 gfio_show_clat_percentiles(main_vbox, ts, ddir);
429 if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) {
430 double p_of_agg = 100.0;
431 const char *bw_str = "KB";
435 p_of_agg = mean * 100 / (double) rs->agg[ddir];
436 if (p_of_agg > 100.0)
440 if (mean > 999999.9) {
448 sprintf(tmp, "Bandwidth (%s)", bw_str);
449 frame = gtk_frame_new(tmp);
450 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
452 box = gtk_hbox_new(FALSE, 3);
453 gtk_container_add(GTK_CONTAINER(frame), box);
455 label = new_info_label_in_frame(box, "Minimum");
456 label_set_int_value(label, min);
457 label = new_info_label_in_frame(box, "Maximum");
458 label_set_int_value(label, max);
459 label = new_info_label_in_frame(box, "Percentage of jobs");
460 sprintf(tmp, "%3.2f%%", p_of_agg);
461 gtk_label_set_text(GTK_LABEL(label), tmp);
462 label = new_info_label_in_frame(box, "Average");
463 sprintf(tmp, "%5.02f", mean);
464 gtk_label_set_text(GTK_LABEL(label), tmp);
465 label = new_info_label_in_frame(box, "Standard deviation");
466 sprintf(tmp, "%5.02f", dev);
467 gtk_label_set_text(GTK_LABEL(label), tmp);
475 static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
478 GtkWidget *tree_view;
479 GtkTreeSelection *selection;
486 * Check if all are empty, in which case don't bother
488 for (i = 0, skipped = 0; i < num; i++)
495 types = malloc(num * sizeof(GType));
497 for (i = 0; i < num; i++)
498 types[i] = G_TYPE_STRING;
500 model = gtk_list_store_newv(num, types);
504 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
505 gtk_widget_set_can_focus(tree_view, FALSE);
507 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
508 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
510 for (i = 0; i < num; i++)
511 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
513 gtk_list_store_append(model, &iter);
515 for (i = 0; i < num; i++) {
519 sprintf(fbuf, "0.00");
521 sprintf(fbuf, "%3.2f%%", lat[i]);
523 gtk_list_store_set(model, &iter, i, fbuf, -1);
529 static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
531 GtkWidget *box, *frame, *tree_view;
532 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
533 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
534 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
535 "250", "500", "750", "1000", };
536 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
537 "250", "500", "750", "1000", "2000",
540 stat_calc_lat_u(ts, io_u_lat_u);
541 stat_calc_lat_m(ts, io_u_lat_m);
543 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
545 frame = gtk_frame_new("Latency buckets (usec)");
546 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
548 box = gtk_hbox_new(FALSE, 3);
549 gtk_container_add(GTK_CONTAINER(frame), box);
550 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
553 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
555 frame = gtk_frame_new("Latency buckets (msec)");
556 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
558 box = gtk_hbox_new(FALSE, 3);
559 gtk_container_add(GTK_CONTAINER(frame), box);
560 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
564 static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
565 struct group_run_stats *rs)
567 GtkWidget *dialog, *box, *vbox, *entry, *content;
568 struct gui *ui = client->client_data;
572 dialog = gtk_dialog_new_with_buttons("Results", GTK_WINDOW(ui->window),
573 GTK_DIALOG_DESTROY_WITH_PARENT,
574 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
576 g_signal_connect_swapped(dialog, "response",
577 G_CALLBACK(gtk_widget_destroy),
580 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
582 vbox = gtk_vbox_new(FALSE, 3);
583 gtk_container_add(GTK_CONTAINER(content), vbox);
585 box = gtk_hbox_new(TRUE, 3);
586 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
588 entry = new_info_entry_in_frame(box, "Name");
589 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
590 if (strlen(ts->description)) {
591 entry = new_info_entry_in_frame(box, "Description");
592 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
594 entry = new_info_entry_in_frame(box, "Group ID");
595 entry_set_int_value(entry, ts->groupid);
596 entry = new_info_entry_in_frame(box, "Jobs");
597 entry_set_int_value(entry, ts->members);
598 entry = new_info_entry_in_frame(box, "Error");
599 entry_set_int_value(entry, ts->error);
600 entry = new_info_entry_in_frame(box, "PID");
601 entry_set_int_value(entry, ts->pid);
603 if (ts->io_bytes[DDIR_READ])
604 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
605 if (ts->io_bytes[DDIR_WRITE])
606 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
608 gfio_show_latency_buckets(vbox, ts);
610 gtk_widget_show_all(dialog);
615 static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
618 GtkTextBuffer *buffer;
621 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui.textview));
623 gtk_text_buffer_get_end_iter(buffer, &end);
624 gtk_text_buffer_insert(buffer, &end, buf, -1);
626 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ui.textview),
627 &end, 0.0, FALSE, 0.0,0.0);
629 fio_client_ops.text_op(client, cmd);
633 static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
635 printf("gfio_disk_util_op called\n");
636 fio_client_ops.disk_util(client, cmd);
639 extern int sum_stat_clients;
640 extern struct thread_stat client_ts;
641 extern struct group_run_stats client_gs;
643 static int sum_stat_nr;
645 static void gfio_thread_status_op(struct fio_client *client,
646 struct fio_net_cmd *cmd)
648 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
650 gfio_display_ts(client, &p->ts, &p->rs);
652 if (sum_stat_clients == 1)
655 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
656 sum_group_stats(&client_gs, &p->rs);
659 client_ts.groupid = p->ts.groupid;
661 if (++sum_stat_nr == sum_stat_clients) {
662 strcpy(client_ts.name, "All clients");
663 gfio_display_ts(client, &client_ts, &client_gs);
667 static void gfio_group_stats_op(struct fio_client *client,
668 struct fio_net_cmd *cmd)
670 printf("gfio_group_stats_op called\n");
671 fio_client_ops.group_stats(client, cmd);
674 static void gfio_update_eta(struct jobs_eta *je)
686 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
687 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
688 eta_to_str(eta_str, je->eta_sec);
691 sprintf(tmp, "%u", je->nr_running);
692 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
693 sprintf(tmp, "%u", je->files_open);
694 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
697 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
698 if (je->m_rate || je->t_rate) {
701 mr = num2str(je->m_rate, 4, 0, i2p);
702 tr = num2str(je->t_rate, 4, 0, i2p);
703 gtk_entry_set_text(GTK_ENTRY(ui.eta);
704 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
707 } else if (je->m_iops || je->t_iops)
708 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
710 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
711 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
712 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
713 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
716 if (je->eta_sec != INT_MAX && je->nr_running) {
720 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
721 strcpy(output, "-.-% done");
725 sprintf(output, "%3.1f%% done", perc);
728 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
729 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
731 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
732 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
734 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
735 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
736 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
737 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
746 char *dst = output + strlen(output);
748 sprintf(dst, " - %s", eta_str);
751 gfio_update_thread_status(output, perc);
754 static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
756 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
757 const char *os, *arch;
760 os = fio_get_os_string(probe->os);
764 arch = fio_get_arch_string(probe->arch);
769 client->name = strdup((char *) probe->hostname);
771 gtk_label_set_text(GTK_LABEL(ui.probe.hostname), (char *) probe->hostname);
772 gtk_label_set_text(GTK_LABEL(ui.probe.os), os);
773 gtk_label_set_text(GTK_LABEL(ui.probe.arch), arch);
774 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
775 gtk_label_set_text(GTK_LABEL(ui.probe.fio_ver), buf);
778 static void gfio_update_thread_status(char *status_message, double perc)
780 static char message[100];
781 const char *m = message;
783 strncpy(message, status_message, sizeof(message) - 1);
784 gtk_progress_bar_set_text(
785 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
786 gtk_progress_bar_set_fraction(
787 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
789 gtk_widget_queue_draw(ui.window);
793 static void gfio_quit_op(struct fio_client *client)
795 struct gui *ui = client->client_data;
797 gfio_set_connected(ui, 0);
800 static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
802 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
803 struct gui *ui = client->client_data;
807 p->iodepth = le32_to_cpu(p->iodepth);
808 p->rw = le32_to_cpu(p->rw);
810 for (i = 0; i < 2; i++) {
811 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
812 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
815 p->numjobs = le32_to_cpu(p->numjobs);
816 p->group_reporting = le32_to_cpu(p->group_reporting);
818 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
819 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
820 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
822 sprintf(tmp, "%u", p->iodepth);
823 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
826 static void gfio_client_timed_out(struct fio_client *client)
828 struct gui *ui = client->client_data;
829 GtkWidget *dialog, *label, *content;
834 gfio_set_connected(ui, 0);
837 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
839 dialog = gtk_dialog_new_with_buttons("Timed out!",
840 GTK_WINDOW(ui->window),
841 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
842 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
844 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
845 label = gtk_label_new((const gchar *) buf);
846 gtk_container_add(GTK_CONTAINER(content), label);
847 gtk_widget_show_all(dialog);
848 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
850 gtk_dialog_run(GTK_DIALOG(dialog));
851 gtk_widget_destroy(dialog);
856 struct client_ops gfio_client_ops = {
857 .text_op = gfio_text_op,
858 .disk_util = gfio_disk_util_op,
859 .thread_status = gfio_thread_status_op,
860 .group_stats = gfio_group_stats_op,
861 .eta = gfio_update_eta,
862 .probe = gfio_probe_op,
863 .quit = gfio_quit_op,
864 .add_job = gfio_add_job_op,
865 .timed_out = gfio_client_timed_out,
869 static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
870 __attribute__((unused)) gpointer data)
875 static void *job_thread(void *arg)
877 fio_handle_clients(&gfio_client_ops);
881 static int send_job_files(struct gui *ui)
885 for (i = 0; i < ui->nr_job_files; i++) {
886 ret = fio_clients_send_ini(ui->job_files[i]);
890 free(ui->job_files[i]);
891 ui->job_files[i] = NULL;
893 while (i < ui->nr_job_files) {
894 free(ui->job_files[i]);
895 ui->job_files[i] = NULL;
902 static void start_job_thread(struct gui *ui)
904 if (send_job_files(ui)) {
905 printf("Yeah, I didn't really like those options too much.\n");
906 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
911 static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
914 struct gui *ui = data;
916 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
917 start_job_thread(ui);
920 static void file_open(GtkWidget *w, gpointer data);
922 static void connect_clicked(GtkWidget *widget, gpointer data)
924 struct gui *ui = data;
926 if (!ui->connected) {
927 if (!ui->nr_job_files)
928 file_open(widget, data);
929 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
930 fio_clients_connect();
931 pthread_create(&ui->t, NULL, job_thread, NULL);
932 gfio_set_connected(ui, 1);
934 fio_clients_terminate();
935 gfio_set_connected(ui, 0);
940 static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
941 struct button_spec *buttonspec)
943 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
944 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
945 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
946 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
947 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
950 static void add_buttons(struct gui *ui,
951 struct button_spec *buttonlist,
956 for (i = 0; i < nbuttons; i++)
957 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
960 static void on_info_bar_response(GtkWidget *widget, gint response,
963 if (response == GTK_RESPONSE_OK) {
964 gtk_widget_destroy(widget);
965 ui.error_info_bar = NULL;
969 void report_error(GError *error)
971 if (ui.error_info_bar == NULL) {
972 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
975 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
976 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
979 ui.error_label = gtk_label_new(error->message);
980 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
981 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
983 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
984 gtk_widget_show_all(ui.vbox);
987 snprintf(buffer, sizeof(buffer), "Failed to open file.");
988 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
992 static int get_connection_details(char **host, int *port, int *type,
995 GtkWidget *dialog, *box, *vbox, *hentry, *hbox, *frame, *pentry, *combo;
999 dialog = gtk_dialog_new_with_buttons("Connection details",
1000 GTK_WINDOW(ui.window),
1001 GTK_DIALOG_DESTROY_WITH_PARENT,
1002 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1003 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1005 frame = gtk_frame_new("Hostname / socket name");
1006 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1007 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1009 box = gtk_vbox_new(FALSE, 6);
1010 gtk_container_add(GTK_CONTAINER(frame), box);
1012 hbox = gtk_hbox_new(TRUE, 10);
1013 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1014 hentry = gtk_entry_new();
1015 gtk_entry_set_text(GTK_ENTRY(hentry), "localhost");
1016 gtk_box_pack_start(GTK_BOX(hbox), hentry, TRUE, TRUE, 0);
1018 frame = gtk_frame_new("Port");
1019 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1020 box = gtk_vbox_new(FALSE, 10);
1021 gtk_container_add(GTK_CONTAINER(frame), box);
1023 hbox = gtk_hbox_new(TRUE, 4);
1024 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1025 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1027 frame = gtk_frame_new("Type");
1028 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1029 box = gtk_vbox_new(FALSE, 10);
1030 gtk_container_add(GTK_CONTAINER(frame), box);
1032 hbox = gtk_hbox_new(TRUE, 4);
1033 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1035 combo = gtk_combo_box_text_new();
1036 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv4");
1037 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv6");
1038 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "local socket");
1039 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
1041 gtk_container_add(GTK_CONTAINER(hbox), combo);
1043 frame = gtk_frame_new("Options");
1044 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1045 box = gtk_vbox_new(FALSE, 10);
1046 gtk_container_add(GTK_CONTAINER(frame), box);
1048 hbox = gtk_hbox_new(TRUE, 4);
1049 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1051 button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1052 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
1053 gtk_widget_set_tooltip_text(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.");
1054 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 6);
1056 gtk_widget_show_all(dialog);
1058 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1059 gtk_widget_destroy(dialog);
1063 *host = strdup(gtk_entry_get_text(GTK_ENTRY(hentry)));
1064 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1066 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
1067 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1068 *type = Fio_client_ipv4;
1069 else if (!strncmp(typeentry, "IPv6", 4))
1070 *type = Fio_client_ipv6;
1072 *type = Fio_client_socket;
1075 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
1077 gtk_widget_destroy(dialog);
1081 static void file_open(GtkWidget *w, gpointer data)
1084 GSList *filenames, *fn_glist;
1085 GtkFileFilter *filter;
1087 int port, type, server_start;
1089 dialog = gtk_file_chooser_dialog_new("Open File",
1090 GTK_WINDOW(ui.window),
1091 GTK_FILE_CHOOSER_ACTION_OPEN,
1092 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1093 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1095 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1097 filter = gtk_file_filter_new();
1098 gtk_file_filter_add_pattern(filter, "*.fio");
1099 gtk_file_filter_add_pattern(filter, "*.job");
1100 gtk_file_filter_add_mime_type(filter, "text/fio");
1101 gtk_file_filter_set_name(filter, "Fio job file");
1102 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1104 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1105 gtk_widget_destroy(dialog);
1109 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
1111 gtk_widget_destroy(dialog);
1113 if (get_connection_details(&host, &port, &type, &server_start))
1116 filenames = fn_glist;
1117 while (filenames != NULL) {
1118 ui.job_files = realloc(ui.job_files, (ui.nr_job_files + 1) * sizeof(char *));
1119 ui.job_files[ui.nr_job_files] = strdup(filenames->data);
1122 ui.client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
1126 error = g_error_new(g_quark_from_string("fio"), 1,
1127 "Failed to add client %s", host);
1128 report_error(error);
1129 g_error_free(error);
1131 ui.client->client_data = &ui;
1133 g_free(filenames->data);
1134 filenames = g_slist_next(filenames);
1138 g_slist_free(fn_glist);
1141 static void file_save(GtkWidget *w, gpointer data)
1145 dialog = gtk_file_chooser_dialog_new("Save File",
1146 GTK_WINDOW(ui.window),
1147 GTK_FILE_CHOOSER_ACTION_SAVE,
1148 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1149 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1152 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1153 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1155 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1158 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1159 // save_job_file(filename);
1162 gtk_widget_destroy(dialog);
1165 static void preferences(GtkWidget *w, gpointer data)
1167 GtkWidget *dialog, *frame, *box, **buttons;
1170 dialog = gtk_dialog_new_with_buttons("Preferences",
1171 GTK_WINDOW(ui.window),
1172 GTK_DIALOG_DESTROY_WITH_PARENT,
1173 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1174 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1177 frame = gtk_frame_new("Debug logging");
1178 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1179 box = gtk_hbox_new(FALSE, 6);
1180 gtk_container_add(GTK_CONTAINER(frame), box);
1182 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1184 for (i = 0; i < FD_DEBUG_MAX; i++) {
1185 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
1186 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
1187 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1190 gtk_widget_show_all(dialog);
1192 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1193 gtk_widget_destroy(dialog);
1197 for (i = 0; i < FD_DEBUG_MAX; i++) {
1200 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1202 fio_debug |= (1UL << i);
1205 gtk_widget_destroy(dialog);
1208 static void about_dialog(GtkWidget *w, gpointer data)
1210 gtk_show_about_dialog(NULL,
1211 "program-name", "gfio",
1212 "comments", "Gtk2 UI for fio",
1214 "version", fio_version_string,
1215 "copyright", "Jens Axboe <axboe@kernel.dk> 2012",
1216 "logo-icon-name", "fio",
1222 static GtkActionEntry menu_items[] = {
1223 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1224 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1225 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1226 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1227 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1228 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1229 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
1231 static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
1233 static const gchar *ui_string = " \
1235 <menubar name=\"MainMenu\"> \
1236 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1237 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1238 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1239 <separator name=\"Separator\"/> \
1240 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1241 <separator name=\"Separator2\"/> \
1242 <menuitem name=\"Quit\" action=\"Quit\" /> \
1244 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1245 <menuitem name=\"About\" action=\"About\" /> \
1251 static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager)
1253 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1256 action_group = gtk_action_group_new("Menu");
1257 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
1259 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1260 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1262 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1263 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1266 void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1267 GtkWidget *vbox, GtkUIManager *ui_manager)
1269 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1272 static void init_ui(int *argc, char **argv[], struct gui *ui)
1274 GtkSettings *settings;
1275 GtkUIManager *uimanager;
1276 GtkWidget *menu, *probe, *probe_frame, *probe_box;
1278 memset(ui, 0, sizeof(*ui));
1280 /* Magical g*thread incantation, you just need this thread stuff.
1281 * Without it, the update that happens in gfio_update_thread_status
1282 * doesn't really happen in a timely fashion, you need expose events
1284 if (!g_thread_supported())
1285 g_thread_init(NULL);
1288 gtk_init(argc, argv);
1289 settings = gtk_settings_get_default();
1290 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1293 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1294 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1295 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 500);
1297 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1298 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
1300 ui->vbox = gtk_vbox_new(FALSE, 0);
1301 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
1303 uimanager = gtk_ui_manager_new();
1304 menu = get_menubar_menu(ui->window, uimanager);
1305 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1308 * Set up alignments for widgets at the top of ui,
1309 * align top left, expand horizontally but not vertically
1311 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
1312 ui->topvbox = gtk_vbox_new(FALSE, 3);
1313 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
1314 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
1316 probe = gtk_frame_new("Job");
1317 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1318 probe_frame = gtk_vbox_new(FALSE, 3);
1319 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1321 probe_box = gtk_hbox_new(FALSE, 3);
1322 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1323 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1324 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1325 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1326 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1328 probe_box = gtk_hbox_new(FALSE, 3);
1329 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1331 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1332 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1333 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1334 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1335 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1336 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
1338 probe_box = gtk_hbox_new(FALSE, 3);
1339 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1340 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1341 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1342 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1343 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
1346 * Only add this if we have a commit rate
1349 probe_box = gtk_hbox_new(FALSE, 3);
1350 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
1352 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1353 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1355 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1356 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1360 * Add a text box for text op messages
1362 ui->textview = gtk_text_view_new();
1363 ui->text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui->textview));
1364 gtk_text_buffer_set_text(ui->text, "", -1);
1365 gtk_text_view_set_editable(GTK_TEXT_VIEW(ui->textview), FALSE);
1366 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ui->textview), FALSE);
1367 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1368 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1369 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1370 gtk_container_add(GTK_CONTAINER(ui->scrolled_window), ui->textview);
1371 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1375 * Set up alignments for widgets at the bottom of ui,
1376 * align bottom left, expand horizontally but not vertically
1378 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1379 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1380 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
1381 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1384 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
1387 * Set up thread status progress bar
1389 ui->thread_status_pb = gtk_progress_bar_new();
1390 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
1391 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
1392 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1395 gtk_widget_show_all(ui->window);
1398 int main(int argc, char *argv[], char *envp[])
1400 if (initialize_fio(envp))
1402 if (fio_init_options())
1405 init_ui(&argc, &argv, &ui);
1407 gdk_threads_enter();
1409 gdk_threads_leave();