projects / fio.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gfio: add extra space to the graphs at the edges
[fio.git] / gfio.c
CommitLineData
ff1f3280
SC		 1/*
2 * gfio - gui front end for fio - the flexible io tester
3 *
4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
c0187f3b 5 * Copyright (C) 2012 Jens Axboe <axboe@kernel.dk>
ff1f3280
SC		 6 *
7 * The license below covers all files distributed with fio unless otherwise
8 * noted in the file itself.
9 *
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.
13 *
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.
18 *
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
22 *
23 */
8232e285 24#include <locale.h>
60f6b330 25#include <malloc.h>
6b79c80c 26#include <string.h>
8232e285 27
5b7573ab 28#include <glib.h>
2fd3bb0e 29#include <cairo.h>
ff1f3280
SC		 30#include <gtk/gtk.h>
31
8232e285 32#include "fio.h"
2fd3bb0e 33#include "graph.h"
8232e285 34
63a130b7 35static int gfio_server_running;
f3e8440f 36static const char *gfio_graph_font;
8577f4fd 37static unsigned int gfio_graph_limit = 100;
63a130b7 38
6b79c80c 39static void view_log(GtkWidget *w, gpointer data);
3e47bd25 40
f3074008
SC		 41#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
42
43typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
44
3e47bd25 45static void connect_clicked(GtkWidget *widget, gpointer data);
f3074008 46static void start_job_clicked(GtkWidget *widget, gpointer data);
b9d2f30a 47static void send_clicked(GtkWidget *widget, gpointer data);
f3074008
SC		 48
49static struct button_spec {
50 const char *buttontext;
51 clickfunction f;
52 const char *tooltiptext;
3e47bd25 53 const int start_insensitive;
f3074008 54} buttonspeclist[] = {
3e47bd25 55#define CONNECT_BUTTON 0
b9d2f30a
JA		 56#define SEND_BUTTON 1
57#define START_JOB_BUTTON 2
3e47bd25 58 { "Connect", connect_clicked, "Connect to host", 0 },
b9d2f30a
JA		 59 { "Send", send_clicked, "Send job description to host", 1 },
60 { "Start Job", start_job_clicked,
2f99deb0 61 "Start the current job on the server", 1 },
f3074008
SC		 62};
63
843ad237
JA		 64struct probe_widget {
65 GtkWidget *hostname;
66 GtkWidget *os;
67 GtkWidget *arch;
68 GtkWidget *fio_ver;
69};
70
3e47bd25 71struct eta_widget {
3863d1ad 72 GtkWidget *names;
807f9971
JA		 73 GtkWidget *iotype;
74 GtkWidget *ioengine;
75 GtkWidget *iodepth;
3e47bd25
JA		 76 GtkWidget *jobs;
77 GtkWidget *files;
78 GtkWidget *read_bw;
79 GtkWidget *read_iops;
80 GtkWidget *cr_bw;
81 GtkWidget *cr_iops;
82 GtkWidget *write_bw;
83 GtkWidget *write_iops;
84 GtkWidget *cw_bw;
85 GtkWidget *cw_iops;
86};
87
2f99deb0
JA		 88struct gfio_graphs {
89#define DRAWING_AREA_XDIM 1000
90#define DRAWING_AREA_YDIM 400
91 GtkWidget *drawing_area;
2f99deb0
JA		 92 struct graph *iops_graph;
93 struct graph *bandwidth_graph;
94};
95
96/*
97 * Main window widgets and data
98 */
ff1f3280
SC		 99struct gui {
100 GtkWidget *window;
2f99deb0
JA		 101 GtkWidget *vbox;
102 GtkWidget *topvbox;
103 GtkWidget *topalign;
104 GtkWidget *bottomalign;
105 GtkWidget *thread_status_pb;
106 GtkWidget *buttonbox;
107 GtkWidget *scrolled_window;
108 GtkWidget *notebook;
109 GtkWidget *error_info_bar;
110 GtkWidget *error_label;
111 GtkListStore *log_model;
112 GtkWidget *log_tree;
113 GtkWidget *log_view;
114 struct gfio_graphs graphs;
115 struct probe_widget probe;
116 struct eta_widget eta;
117 pthread_t server_t;
118
a9eccde4
JA		 119 pthread_t t;
120 int handler_running;
121
2f99deb0
JA		 122 struct flist_head list;
123} main_ui;
124
125/*
126 * Notebook entry
127 */
128struct gui_entry {
129 struct flist_head list;
130 struct gui *ui;
131
5b7573ab 132 GtkWidget *vbox;
c36f98d9
SC		 133 GtkWidget *topvbox;
134 GtkWidget *topalign;
135 GtkWidget *bottomalign;
04cc6b77 136 GtkWidget *thread_status_pb;
f3074008
SC		 137 GtkWidget *buttonbox;
138 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
736f2dff 139 GtkWidget *scrolled_window;
2f99deb0 140 GtkWidget *notebook;
0420ba6a
JA		 141 GtkWidget *error_info_bar;
142 GtkWidget *error_label;
f9d40b48
JA		 143 GtkWidget *results_notebook;
144 GtkWidget *results_window;
9b260bdf
JA		 145 GtkListStore *log_model;
146 GtkWidget *log_tree;
4cbe7211 147 GtkWidget *log_view;
2f99deb0 148 struct gfio_graphs graphs;
843ad237 149 struct probe_widget probe;
3e47bd25 150 struct eta_widget eta;
2f99deb0
JA		 151 GtkWidget *page_label;
152 gint page_num;
3ec62ec4 153 int connected;
0420ba6a 154
b9d2f30a 155 struct gfio_client *client;
0420ba6a
JA		 156 int nr_job_files;
157 char **job_files;
2f99deb0 158};
ff1f3280 159
e0681f3e 160struct gfio_client {
2f99deb0 161 struct gui_entry *ge;
b9d2f30a 162 struct fio_client *client;
e0681f3e
JA		 163 GtkWidget *results_widget;
164 GtkWidget *disk_util_frame;
6b79c80c 165 GtkWidget *err_entry;
dcaeb606
JA		 166 unsigned int job_added;
167 struct thread_options o;
e0681f3e
JA		 168};
169
9988ca70
JA		 170static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
171static void gfio_update_thread_status_all(char *status_message, double perc);
c724926b 172void report_error(GError *error);
9988ca70 173
f0af9f84
SC		 174static void iops_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
175{
176 switch (power_of_ten) {
177 case 9: graph_y_title(g, "Billions of IOs / sec");
178 break;
179 case 6: graph_y_title(g, "Millions of IOs / sec");
180 break;
181 case 3: graph_y_title(g, "Thousands of IOs / sec");
182 break;
183 case 0:
184 default: graph_y_title(g, "IOs / sec");
185 break;
186 }
187}
188
2f99deb0
JA		 189static struct graph *setup_iops_graph(void)
190{
191 struct graph *g;
192
193 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
194 graph_title(g, "IOPS");
195 graph_x_title(g, "Time (secs)");
196 graph_y_title(g, "IOs / sec");
197 graph_add_label(g, "Read IOPS");
198 graph_add_label(g, "Write IOPS");
199 graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
200 graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
8577f4fd 201 line_graph_set_data_count_limit(g, gfio_graph_limit);
f0af9f84 202 graph_y_axis_unit_change_notify(g, iops_graph_y_axis_unit_change);
def0ac29 203 graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
2f99deb0
JA		 204 return g;
205}
206
f0af9f84
SC		 207static void bandwidth_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
208{
209 switch (power_of_ten) {
210 case 9: graph_y_title(g, "Petabytes / sec");
211 break;
212 case 6: graph_y_title(g, "Gigabytes / sec");
213 break;
214 case 3: graph_y_title(g, "Megabytes / sec");
215 break;
216 case 0:
217 default: graph_y_title(g, "Kilobytes / sec");
218 break;
219 }
220}
221
2f99deb0
JA		 222static struct graph *setup_bandwidth_graph(void)
223{
224 struct graph *g;
225
226 g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
227 graph_title(g, "Bandwidth");
228 graph_x_title(g, "Time (secs)");
229 graph_y_title(g, "Kbytes / sec");
230 graph_add_label(g, "Read Bandwidth");
231 graph_add_label(g, "Write Bandwidth");
232 graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
233 graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
234 line_graph_set_data_count_limit(g, 100);
f0af9f84 235 graph_y_axis_unit_change_notify(g, bandwidth_graph_y_axis_unit_change);
def0ac29
SC		 236 graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
237
2f99deb0
JA		 238 return g;
239}
240
241static void setup_graphs(struct gfio_graphs *g)
242{
243 g->iops_graph = setup_iops_graph();
244 g->bandwidth_graph = setup_bandwidth_graph();
245}
246
247static void clear_ge_ui_info(struct gui_entry *ge)
248{
249 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
250 gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
251 gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
252 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
3863d1ad
JA		 253#if 0
254 /* should we empty it... */
2f99deb0 255 gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
3863d1ad 256#endif
2f99deb0
JA		 257 gtk_entry_set_text(GTK_ENTRY(ge->eta.iotype), "");
258 gtk_entry_set_text(GTK_ENTRY(ge->eta.ioengine), "");
259 gtk_entry_set_text(GTK_ENTRY(ge->eta.iodepth), "");
260 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
261 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
262 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
263 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
264 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
265 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
8663ea65
JA		 266}
267
3863d1ad
JA		 268static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label)
269{
270 GtkWidget *entry, *frame;
271
272 frame = gtk_frame_new(label);
273 entry = gtk_combo_box_new_text();
274 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
275 gtk_container_add(GTK_CONTAINER(frame), entry);
276
277 return entry;
278}
279
3650a3ca
JA		 280static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
281{
282 GtkWidget *entry, *frame;
283
284 frame = gtk_frame_new(label);
285 entry = gtk_entry_new();
1c1e4a5b 286 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
3650a3ca
JA		 287 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
288 gtk_container_add(GTK_CONTAINER(frame), entry);
289
290 return entry;
291}
292
293static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
294{
295 GtkWidget *label_widget;
296 GtkWidget *frame;
297
298 frame = gtk_frame_new(label);
299 label_widget = gtk_label_new(NULL);
300 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
301 gtk_container_add(GTK_CONTAINER(frame), label_widget);
302
303 return label_widget;
304}
305
306static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
307{
308 GtkWidget *button, *box;
309
310 box = gtk_hbox_new(FALSE, 3);
311 gtk_container_add(GTK_CONTAINER(hbox), box);
312
313 button = gtk_spin_button_new_with_range(min, max, 1.0);
314 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
315
316 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
317 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
318
319 return button;
320}
321
2f99deb0 322static void gfio_set_connected(struct gui_entry *ge, int connected)
3ec62ec4
JA		 323{
324 if (connected) {
2f99deb0
JA		 325 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 1);
326 ge->connected = 1;
327 gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Disconnect");
328 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 1);
3ec62ec4 329 } else {
2f99deb0
JA		 330 ge->connected = 0;
331 gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Connect");
332 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 0);
333 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
334 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 1);
3ec62ec4
JA		 335 }
336}
337
3650a3ca
JA		 338static void label_set_int_value(GtkWidget *entry, unsigned int val)
339{
340 char tmp[80];
341
342 sprintf(tmp, "%u", val);
343 gtk_label_set_text(GTK_LABEL(entry), tmp);
344}
345
346static void entry_set_int_value(GtkWidget *entry, unsigned int val)
347{
348 char tmp[80];
349
350 sprintf(tmp, "%u", val);
351 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
352}
353
a269790c
JA		 354#define ALIGN_LEFT 1
355#define ALIGN_RIGHT 2
356#define INVISIBLE 4
357#define UNSORTABLE 8
358
359GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
360{
361 GtkCellRenderer *renderer;
362 GtkTreeViewColumn *col;
363 double xalign = 0.0; /* left as default */
364 PangoAlignment align;
365 gboolean visible;
366
367 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
368 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
369 PANGO_ALIGN_CENTER;
370 visible = !(flags & INVISIBLE);
371
372 renderer = gtk_cell_renderer_text_new();
373 col = gtk_tree_view_column_new();
374
375 gtk_tree_view_column_set_title(col, title);
376 if (!(flags & UNSORTABLE))
377 gtk_tree_view_column_set_sort_column_id(col, index);
378 gtk_tree_view_column_set_resizable(col, TRUE);
379 gtk_tree_view_column_pack_start(col, renderer, TRUE);
380 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
381 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
382 switch (align) {
383 case PANGO_ALIGN_LEFT:
384 xalign = 0.0;
385 break;
386 case PANGO_ALIGN_CENTER:
387 xalign = 0.5;
388 break;
389 case PANGO_ALIGN_RIGHT:
390 xalign = 1.0;
391 break;
392 }
393 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
394 gtk_tree_view_column_set_visible(col, visible);
395 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
396 return col;
397}
398
9b260bdf
JA		 399static void gfio_ui_setup_log(struct gui *ui)
400{
401 GtkTreeSelection *selection;
402 GtkListStore *model;
403 GtkWidget *tree_view;
404
405 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
406
407 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
408 gtk_widget_set_can_focus(tree_view, FALSE);
409
410 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
411 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
661f741a
JA		 412 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
413 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
9b260bdf
JA		 414
415 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
416 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
417 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
f095d563 418 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
9b260bdf
JA		 419
420 ui->log_model = model;
421 ui->log_tree = tree_view;
422}
423
a269790c
JA		 424static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
425 fio_fp64_t *plist,
426 unsigned int len,
427 const char *base,
428 unsigned int scale)
429{
430 GType types[FIO_IO_U_LIST_MAX_LEN];
431 GtkWidget *tree_view;
432 GtkTreeSelection *selection;
433 GtkListStore *model;
434 GtkTreeIter iter;
435 int i;
436
437 for (i = 0; i < len; i++)
438 types[i] = G_TYPE_INT;
439
440 model = gtk_list_store_newv(len, types);
441
442 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
443 gtk_widget_set_can_focus(tree_view, FALSE);
444
661f741a
JA		 445 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
446 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
447
a269790c
JA		 448 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
449 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
450
451 for (i = 0; i < len; i++) {
452 char fbuf[8];
453
454 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
455 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
456 }
457
458 gtk_list_store_append(model, &iter);
459
e0681f3e
JA		 460 for (i = 0; i < len; i++) {
461 if (scale)
462 ovals[i] = (ovals[i] + 999) / 1000;
a269790c 463 gtk_list_store_set(model, &iter, i, ovals[i], -1);
e0681f3e 464 }
a269790c
JA		 465
466 return tree_view;
467}
468
469static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
470 int ddir)
471{
472 unsigned int *io_u_plat = ts->io_u_plat[ddir];
473 unsigned long nr = ts->clat_stat[ddir].samples;
474 fio_fp64_t *plist = ts->percentile_list;
475 unsigned int *ovals, len, minv, maxv, scale_down;
476 const char *base;
477 GtkWidget *tree_view, *frame, *hbox;
478 char tmp[64];
479
480 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
481 if (!len)
482 goto out;
483
484 /*
485 * We default to usecs, but if the value range is such that we
486 * should scale down to msecs, do that.
487 */
488 if (minv > 2000 && maxv > 99999) {
489 scale_down = 1;
490 base = "msec";
491 } else {
492 scale_down = 0;
493 base = "usec";
494 }
495
496 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
497
498 sprintf(tmp, "Completion percentiles (%s)", base);
499 frame = gtk_frame_new(tmp);
500 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
501
502 hbox = gtk_hbox_new(FALSE, 3);
503 gtk_container_add(GTK_CONTAINER(frame), hbox);
504
505 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
506out:
507 if (ovals)
508 free(ovals);
509}
510
3650a3ca
JA		 511static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
512 unsigned long max, double mean, double dev)
513{
514 const char *base = "(usec)";
1c1e4a5b 515 GtkWidget *hbox, *label, *frame;
3650a3ca
JA		 516 char *minp, *maxp;
517 char tmp[64];
518
519 if (!usec_to_msec(&min, &max, &mean, &dev))
520 base = "(msec)";
521
522 minp = num2str(min, 6, 1, 0);
523 maxp = num2str(max, 6, 1, 0);
524
3650a3ca
JA		 525 sprintf(tmp, "%s %s", name, base);
526 frame = gtk_frame_new(tmp);
527 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
528
3650a3ca 529 hbox = gtk_hbox_new(FALSE, 3);
1c1e4a5b 530 gtk_container_add(GTK_CONTAINER(frame), hbox);
3650a3ca
JA		 531
532 label = new_info_label_in_frame(hbox, "Minimum");
533 gtk_label_set_text(GTK_LABEL(label), minp);
534 label = new_info_label_in_frame(hbox, "Maximum");
535 gtk_label_set_text(GTK_LABEL(label), maxp);
536 label = new_info_label_in_frame(hbox, "Average");
537 sprintf(tmp, "%5.02f", mean);
538 gtk_label_set_text(GTK_LABEL(label), tmp);
539 label = new_info_label_in_frame(hbox, "Standard deviation");
540 sprintf(tmp, "%5.02f", dev);
541 gtk_label_set_text(GTK_LABEL(label), tmp);
542
543 free(minp);
544 free(maxp);
545
546}
547
ca850992
JA		 548#define GFIO_CLAT 1
549#define GFIO_SLAT 2
550#define GFIO_LAT 4
551
3650a3ca
JA		 552static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
553 struct thread_stat *ts, int ddir)
554{
555 const char *ddir_label[2] = { "Read", "Write" };
0b761306 556 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
e0681f3e 557 unsigned long min[3], max[3], runt;
3650a3ca 558 unsigned long long bw, iops;
ca850992 559 unsigned int flags = 0;
e0681f3e 560 double mean[3], dev[3];
3650a3ca
JA		 561 char *io_p, *bw_p, *iops_p;
562 int i2p;
563
564 if (!ts->runtime[ddir])
565 return;
566
567 i2p = is_power_of_2(rs->kb_base);
568 runt = ts->runtime[ddir];
569
570 bw = (1000 * ts->io_bytes[ddir]) / runt;
571 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
572 bw_p = num2str(bw, 6, 1, i2p);
573
574 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
575 iops_p = num2str(iops, 6, 1, 0);
576
577 box = gtk_hbox_new(FALSE, 3);
578 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
579
580 frame = gtk_frame_new(ddir_label[ddir]);
581 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
582
0b761306
JA		 583 main_vbox = gtk_vbox_new(FALSE, 3);
584 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
3650a3ca
JA		 585
586 box = gtk_hbox_new(FALSE, 3);
0b761306 587 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
3650a3ca
JA		 588
589 label = new_info_label_in_frame(box, "IO");
590 gtk_label_set_text(GTK_LABEL(label), io_p);
591 label = new_info_label_in_frame(box, "Bandwidth");
592 gtk_label_set_text(GTK_LABEL(label), bw_p);
593 label = new_info_label_in_frame(box, "IOPS");
594 gtk_label_set_text(GTK_LABEL(label), iops_p);
595 label = new_info_label_in_frame(box, "Runtime (msec)");
596 label_set_int_value(label, ts->runtime[ddir]);
597
e0681f3e 598 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
ca850992
JA		 599 double p_of_agg = 100.0;
600 const char *bw_str = "KB";
601 char tmp[32];
602
603 if (rs->agg[ddir]) {
e0681f3e 604 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
ca850992
JA		 605 if (p_of_agg > 100.0)
606 p_of_agg = 100.0;
607 }
608
e0681f3e
JA		 609 if (mean[0] > 999999.9) {
610 min[0] /= 1000.0;
611 max[0] /= 1000.0;
612 mean[0] /= 1000.0;
613 dev[0] /= 1000.0;
ca850992
JA		 614 bw_str = "MB";
615 }
616
0b761306
JA		 617 sprintf(tmp, "Bandwidth (%s)", bw_str);
618 frame = gtk_frame_new(tmp);
619 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
ca850992 620
0b761306
JA		 621 box = gtk_hbox_new(FALSE, 3);
622 gtk_container_add(GTK_CONTAINER(frame), box);
ca850992 623
0b761306 624 label = new_info_label_in_frame(box, "Minimum");
e0681f3e 625 label_set_int_value(label, min[0]);
0b761306 626 label = new_info_label_in_frame(box, "Maximum");
e0681f3e 627 label_set_int_value(label, max[0]);
0b761306 628 label = new_info_label_in_frame(box, "Percentage of jobs");
ca850992
JA		 629 sprintf(tmp, "%3.2f%%", p_of_agg);
630 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 631 label = new_info_label_in_frame(box, "Average");
e0681f3e 632 sprintf(tmp, "%5.02f", mean[0]);
ca850992 633 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 634 label = new_info_label_in_frame(box, "Standard deviation");
e0681f3e 635 sprintf(tmp, "%5.02f", dev[0]);
ca850992
JA		 636 gtk_label_set_text(GTK_LABEL(label), tmp);
637 }
638
e0681f3e 639 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
2b089892 640 flags |= GFIO_SLAT;
e0681f3e 641 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
2b089892 642 flags |= GFIO_CLAT;
e0681f3e 643 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
2b089892
JA		 644 flags |= GFIO_LAT;
645
646 if (flags) {
647 frame = gtk_frame_new("Latency");
648 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
649
650 vbox = gtk_vbox_new(FALSE, 3);
651 gtk_container_add(GTK_CONTAINER(frame), vbox);
652
653 if (flags & GFIO_SLAT)
e0681f3e 654 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
2b089892 655 if (flags & GFIO_CLAT)
e0681f3e 656 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
2b089892 657 if (flags & GFIO_LAT)
e0681f3e 658 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
2b089892
JA		 659 }
660
661 if (ts->clat_percentiles)
662 gfio_show_clat_percentiles(main_vbox, ts, ddir);
663
664
3650a3ca
JA		 665 free(io_p);
666 free(bw_p);
667 free(iops_p);
668}
669
e5bd1347
JA		 670static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
671 const char **labels)
672{
673 GtkWidget *tree_view;
674 GtkTreeSelection *selection;
675 GtkListStore *model;
676 GtkTreeIter iter;
677 GType *types;
678 int i, skipped;
679
680 /*
681 * Check if all are empty, in which case don't bother
682 */
683 for (i = 0, skipped = 0; i < num; i++)
684 if (lat[i] <= 0.0)
685 skipped++;
686
687 if (skipped == num)
688 return NULL;
689
690 types = malloc(num * sizeof(GType));
691
692 for (i = 0; i < num; i++)
693 types[i] = G_TYPE_STRING;
694
695 model = gtk_list_store_newv(num, types);
696 free(types);
697 types = NULL;
698
699 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
700 gtk_widget_set_can_focus(tree_view, FALSE);
701
661f741a
JA		 702 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
703 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
704
e5bd1347
JA		 705 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
706 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
707
708 for (i = 0; i < num; i++)
709 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
710
711 gtk_list_store_append(model, &iter);
712
713 for (i = 0; i < num; i++) {
714 char fbuf[32];
715
716 if (lat[i] <= 0.0)
717 sprintf(fbuf, "0.00");
718 else
719 sprintf(fbuf, "%3.2f%%", lat[i]);
720
721 gtk_list_store_set(model, &iter, i, fbuf, -1);
722 }
723
724 return tree_view;
725}
726
727static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
728{
729 GtkWidget *box, *frame, *tree_view;
730 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
731 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
732 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
733 "250", "500", "750", "1000", };
734 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
735 "250", "500", "750", "1000", "2000",
736 ">= 2000", };
737
738 stat_calc_lat_u(ts, io_u_lat_u);
739 stat_calc_lat_m(ts, io_u_lat_m);
740
741 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
742 if (tree_view) {
743 frame = gtk_frame_new("Latency buckets (usec)");
744 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
745
746 box = gtk_hbox_new(FALSE, 3);
747 gtk_container_add(GTK_CONTAINER(frame), box);
748 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
749 }
750
751 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
752 if (tree_view) {
753 frame = gtk_frame_new("Latency buckets (msec)");
754 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
755
756 box = gtk_hbox_new(FALSE, 3);
757 gtk_container_add(GTK_CONTAINER(frame), box);
758 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
759 }
760}
761
2e33101f
JA		 762static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
763{
764 GtkWidget *box, *frame, *entry;
765 double usr_cpu, sys_cpu;
766 unsigned long runtime;
767 char tmp[32];
768
769 runtime = ts->total_run_time;
770 if (runtime) {
771 double runt = (double) runtime;
772
773 usr_cpu = (double) ts->usr_time * 100 / runt;
774 sys_cpu = (double) ts->sys_time * 100 / runt;
775 } else {
776 usr_cpu = 0;
777 sys_cpu = 0;
778 }
779
780 frame = gtk_frame_new("OS resources");
781 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
782
783 box = gtk_hbox_new(FALSE, 3);
784 gtk_container_add(GTK_CONTAINER(frame), box);
785
786 entry = new_info_entry_in_frame(box, "User CPU");
787 sprintf(tmp, "%3.2f%%", usr_cpu);
788 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
789 entry = new_info_entry_in_frame(box, "System CPU");
790 sprintf(tmp, "%3.2f%%", sys_cpu);
791 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
792 entry = new_info_entry_in_frame(box, "Context switches");
793 entry_set_int_value(entry, ts->ctx);
794 entry = new_info_entry_in_frame(box, "Major faults");
795 entry_set_int_value(entry, ts->majf);
796 entry = new_info_entry_in_frame(box, "Minor faults");
797 entry_set_int_value(entry, ts->minf);
798}
19998dbc
JA		 799static void gfio_add_sc_depths_tree(GtkListStore *model,
800 struct thread_stat *ts, unsigned int len,
801 int submit)
2e33101f
JA		 802{
803 double io_u_dist[FIO_IO_U_MAP_NR];
2e33101f 804 GtkTreeIter iter;
19998dbc
JA		 805 /* Bits 0, and 3-8 */
806 const int add_mask = 0x1f9;
807 int i, j;
2e33101f 808
19998dbc
JA		 809 if (submit)
810 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
811 else
812 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
2e33101f 813
19998dbc 814 gtk_list_store_append(model, &iter);
2e33101f 815
19998dbc 816 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
2e33101f 817
19998dbc
JA		 818 for (i = 1, j = 0; i < len; i++) {
819 char fbuf[32];
2e33101f 820
19998dbc
JA		 821 if (!(add_mask & (1UL << (i - 1))))
822 sprintf(fbuf, "0.0%%");
823 else {
824 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
825 j++;
826 }
2e33101f 827
19998dbc
JA		 828 gtk_list_store_set(model, &iter, i, fbuf, -1);
829 }
2e33101f 830
19998dbc 831}
2e33101f 832
19998dbc
JA		 833static void gfio_add_total_depths_tree(GtkListStore *model,
834 struct thread_stat *ts, unsigned int len)
835{
836 double io_u_dist[FIO_IO_U_MAP_NR];
837 GtkTreeIter iter;
838 /* Bits 1-6, and 8 */
839 const int add_mask = 0x17e;
840 int i, j;
841
842 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
2e33101f
JA		 843
844 gtk_list_store_append(model, &iter);
845
19998dbc
JA		 846 gtk_list_store_set(model, &iter, 0, "Total", -1);
847
848 for (i = 1, j = 0; i < len; i++) {
2e33101f
JA		 849 char fbuf[32];
850
19998dbc
JA		 851 if (!(add_mask & (1UL << (i - 1))))
852 sprintf(fbuf, "0.0%%");
853 else {
854 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
855 j++;
2e33101f
JA		 856 }
857
2e33101f
JA		 858 gtk_list_store_set(model, &iter, i, fbuf, -1);
859 }
860
19998dbc 861}
2e33101f 862
19998dbc
JA		 863static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
864{
865 GtkWidget *frame, *box, *tree_view;
866 GtkTreeSelection *selection;
867 GtkListStore *model;
868 GType types[FIO_IO_U_MAP_NR + 1];
869 int i;
870#define NR_LABELS 10
871 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
2e33101f 872
19998dbc
JA		 873 frame = gtk_frame_new("IO depths");
874 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2e33101f 875
19998dbc
JA		 876 box = gtk_hbox_new(FALSE, 3);
877 gtk_container_add(GTK_CONTAINER(frame), box);
2e33101f 878
19998dbc
JA		 879 for (i = 0; i < NR_LABELS; i++)
880 types[i] = G_TYPE_STRING;
2e33101f 881
19998dbc 882 model = gtk_list_store_newv(NR_LABELS, types);
2e33101f 883
19998dbc
JA		 884 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
885 gtk_widget_set_can_focus(tree_view, FALSE);
2e33101f 886
661f741a
JA		 887 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
888 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
889
19998dbc
JA		 890 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
891 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
892
893 for (i = 0; i < NR_LABELS; i++)
894 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
895
896 gfio_add_total_depths_tree(model, ts, NR_LABELS);
897 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
898 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
2e33101f
JA		 899
900 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
901}
902
f9d40b48
JA		 903static gboolean results_window_delete(GtkWidget *w, gpointer data)
904{
2f99deb0 905 struct gui_entry *ge = (struct gui_entry *) data;
f9d40b48
JA		 906
907 gtk_widget_destroy(w);
2f99deb0
JA		 908 ge->results_window = NULL;
909 ge->results_notebook = NULL;
f9d40b48
JA		 910 return TRUE;
911}
912
2f99deb0 913static GtkWidget *get_results_window(struct gui_entry *ge)
f9d40b48
JA		 914{
915 GtkWidget *win, *notebook;
916
2f99deb0
JA		 917 if (ge->results_window)
918 return ge->results_notebook;
f9d40b48
JA		 919
920 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
921 gtk_window_set_title(GTK_WINDOW(win), "Results");
b01329d0 922 gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768);
2f99deb0
JA		 923 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
924 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
f9d40b48
JA		 925
926 notebook = gtk_notebook_new();
0aa928c4
JA		 927 gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
928 gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
f9d40b48
JA		 929 gtk_container_add(GTK_CONTAINER(win), notebook);
930
2f99deb0
JA		 931 ge->results_window = win;
932 ge->results_notebook = notebook;
933 return ge->results_notebook;
f9d40b48
JA		 934}
935
3650a3ca
JA		 936static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
937 struct group_run_stats *rs)
938{
b01329d0 939 GtkWidget *res_win, *box, *vbox, *entry, *scroll;
e0681f3e 940 struct gfio_client *gc = client->client_data;
3650a3ca
JA		 941
942 gdk_threads_enter();
943
2f99deb0 944 res_win = get_results_window(gc->ge);
3650a3ca 945
b01329d0
JA		 946 scroll = gtk_scrolled_window_new(NULL, NULL);
947 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
948 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
949
3650a3ca 950 vbox = gtk_vbox_new(FALSE, 3);
3650a3ca 951
b01329d0
JA		 952 box = gtk_hbox_new(FALSE, 0);
953 gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5);
954
955 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
3650a3ca 956
b01329d0 957 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name));
f9d40b48 958
e0681f3e
JA		 959 gc->results_widget = vbox;
960
3650a3ca
JA		 961 entry = new_info_entry_in_frame(box, "Name");
962 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
963 if (strlen(ts->description)) {
964 entry = new_info_entry_in_frame(box, "Description");
965 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
966 }
967 entry = new_info_entry_in_frame(box, "Group ID");
968 entry_set_int_value(entry, ts->groupid);
969 entry = new_info_entry_in_frame(box, "Jobs");
970 entry_set_int_value(entry, ts->members);
6b79c80c 971 gc->err_entry = entry = new_info_entry_in_frame(box, "Error");
3650a3ca
JA		 972 entry_set_int_value(entry, ts->error);
973 entry = new_info_entry_in_frame(box, "PID");
974 entry_set_int_value(entry, ts->pid);
975
976 if (ts->io_bytes[DDIR_READ])
977 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
978 if (ts->io_bytes[DDIR_WRITE])
979 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
980
e5bd1347 981 gfio_show_latency_buckets(vbox, ts);
2e33101f
JA		 982 gfio_show_cpu_usage(vbox, ts);
983 gfio_show_io_depths(vbox, ts);
e5bd1347 984
2f99deb0 985 gtk_widget_show_all(gc->ge->results_window);
3650a3ca
JA		 986 gdk_threads_leave();
987}
988
084d1c6f 989static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
a1820207 990{
9b260bdf 991 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
2f99deb0 992 struct gui *ui = &main_ui;
9b260bdf
JA		 993 GtkTreeIter iter;
994 struct tm *tm;
995 time_t sec;
996 char tmp[64], timebuf[80];
997
998 sec = p->log_sec;
999 tm = localtime(&sec);
1000 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
1001 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
736f2dff 1002
736f2dff 1003 gdk_threads_enter();
9b260bdf 1004
2f99deb0
JA		 1005 gtk_list_store_append(ui->log_model, &iter);
1006 gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1);
1007 gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1);
1008 gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1);
1009 gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1);
9b260bdf 1010
6b79c80c 1011 if (p->level == FIO_LOG_ERR)
2f99deb0 1012 view_log(NULL, (gpointer) ui);
6b79c80c 1013
736f2dff 1014 gdk_threads_leave();
a1820207
SC		 1015}
1016
1017static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
1018{
e0681f3e
JA		 1019 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
1020 struct gfio_client *gc = client->client_data;
1021 GtkWidget *box, *frame, *entry, *vbox;
604cfe30
JA		 1022 double util;
1023 char tmp[16];
e0681f3e 1024
0050e5f2 1025 gdk_threads_enter();
e0681f3e 1026
45dcb2eb 1027 if (!gc->results_widget)
e0681f3e 1028 goto out;
e0681f3e
JA		 1029
1030 if (!gc->disk_util_frame) {
1031 gc->disk_util_frame = gtk_frame_new("Disk utilization");
1032 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
1033 }
1034
1035 vbox = gtk_vbox_new(FALSE, 3);
1036 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
1037
1038 frame = gtk_frame_new((char *) p->dus.name);
1039 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
1040
1041 box = gtk_vbox_new(FALSE, 3);
1042 gtk_container_add(GTK_CONTAINER(frame), box);
1043
1044 frame = gtk_frame_new("Read");
1045 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1046 vbox = gtk_hbox_new(TRUE, 3);
1047 gtk_container_add(GTK_CONTAINER(frame), vbox);
1048 entry = new_info_entry_in_frame(vbox, "IOs");
1049 entry_set_int_value(entry, p->dus.ios[0]);
1050 entry = new_info_entry_in_frame(vbox, "Merges");
1051 entry_set_int_value(entry, p->dus.merges[0]);
1052 entry = new_info_entry_in_frame(vbox, "Sectors");
1053 entry_set_int_value(entry, p->dus.sectors[0]);
1054 entry = new_info_entry_in_frame(vbox, "Ticks");
1055 entry_set_int_value(entry, p->dus.ticks[0]);
1056
1057 frame = gtk_frame_new("Write");
1058 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1059 vbox = gtk_hbox_new(TRUE, 3);
1060 gtk_container_add(GTK_CONTAINER(frame), vbox);
1061 entry = new_info_entry_in_frame(vbox, "IOs");
1062 entry_set_int_value(entry, p->dus.ios[1]);
1063 entry = new_info_entry_in_frame(vbox, "Merges");
1064 entry_set_int_value(entry, p->dus.merges[1]);
1065 entry = new_info_entry_in_frame(vbox, "Sectors");
1066 entry_set_int_value(entry, p->dus.sectors[1]);
1067 entry = new_info_entry_in_frame(vbox, "Ticks");
1068 entry_set_int_value(entry, p->dus.ticks[1]);
1069
1070 frame = gtk_frame_new("Shared");
1071 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
1072 vbox = gtk_hbox_new(TRUE, 3);
1073 gtk_container_add(GTK_CONTAINER(frame), vbox);
1074 entry = new_info_entry_in_frame(vbox, "IO ticks");
1075 entry_set_int_value(entry, p->dus.io_ticks);
1076 entry = new_info_entry_in_frame(vbox, "Time in queue");
1077 entry_set_int_value(entry, p->dus.time_in_queue);
1078
604cfe30
JA		 1079 util = 0.0;
1080 if (p->dus.msec)
1081 util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec;
1082 if (util > 100.0)
1083 util = 100.0;
1084
1085 sprintf(tmp, "%3.2f%%", util);
1086 entry = new_info_entry_in_frame(vbox, "Disk utilization");
1087 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
1088
e0681f3e
JA		 1089 gtk_widget_show_all(gc->results_widget);
1090out:
0050e5f2 1091 gdk_threads_leave();
a1820207
SC		 1092}
1093
3650a3ca
JA		 1094extern int sum_stat_clients;
1095extern struct thread_stat client_ts;
1096extern struct group_run_stats client_gs;
1097
1098static int sum_stat_nr;
1099
89e5fad9
JA		 1100static void gfio_thread_status_op(struct fio_client *client,
1101 struct fio_net_cmd *cmd)
a1820207 1102{
3650a3ca
JA		 1103 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
1104
1105 gfio_display_ts(client, &p->ts, &p->rs);
1106
1107 if (sum_stat_clients == 1)
1108 return;
1109
1110 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
1111 sum_group_stats(&client_gs, &p->rs);
1112
1113 client_ts.members++;
1114 client_ts.groupid = p->ts.groupid;
1115
1116 if (++sum_stat_nr == sum_stat_clients) {
1117 strcpy(client_ts.name, "All clients");
1118 gfio_display_ts(client, &client_ts, &client_gs);
1119 }
a1820207
SC		 1120}
1121
89e5fad9
JA		 1122static void gfio_group_stats_op(struct fio_client *client,
1123 struct fio_net_cmd *cmd)
a1820207 1124{
98ceabd6 1125 /* We're ignoring group stats for now */
a1820207
SC		 1126}
1127
2f99deb0
JA		 1128static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
1129 gpointer data)
3ea48b88 1130{
2f99deb0
JA		 1131 struct gfio_graphs *g = data;
1132
57f9d28e
SC		 1133 graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height);
1134 graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0);
1135 graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height);
1136 graph_set_position(g->bandwidth_graph, 0, 0);
3ea48b88
SC		 1137 return TRUE;
1138}
1139
57f9d28e
SC		 1140static void draw_graph(struct graph *g, cairo_t *cr)
1141{
1142 line_graph_draw(g, cr);
1143 cairo_stroke(cr);
1144}
1145
2fd3bb0e
JA		 1146static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1147{
2f99deb0 1148 struct gfio_graphs *g = p;
2fd3bb0e
JA		 1149 cairo_t *cr;
1150
1151 cr = gdk_cairo_create(w->window);
2fd3bb0e 1152 cairo_set_source_rgb(cr, 0, 0, 0);
57f9d28e
SC		 1153 draw_graph(g->iops_graph, cr);
1154 draw_graph(g->bandwidth_graph, cr);
2fd3bb0e
JA		 1155 cairo_destroy(cr);
1156
1157 return FALSE;
1158}
1159
2f99deb0
JA		 1160/*
1161 * Client specific ETA
1162 */
1163static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je)
3e47bd25 1164{
2f99deb0
JA		 1165 struct gfio_client *gc = client->client_data;
1166 struct gui_entry *ge = gc->ge;
3e47bd25
JA		 1167 static int eta_good;
1168 char eta_str[128];
1169 char output[256];
1170 char tmp[32];
1171 double perc = 0.0;
1172 int i2p = 0;
1173
0050e5f2
JA		 1174 gdk_threads_enter();
1175
3e47bd25
JA		 1176 eta_str[0] = '\0';
1177 output[0] = '\0';
1178
1179 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1180 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1181 eta_to_str(eta_str, je->eta_sec);
1182 }
1183
1184 sprintf(tmp, "%u", je->nr_running);
2f99deb0 1185 gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), tmp);
3e47bd25 1186 sprintf(tmp, "%u", je->files_open);
2f99deb0 1187 gtk_entry_set_text(GTK_ENTRY(ge->eta.files), tmp);
3e47bd25
JA		 1188
1189#if 0
1190 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1191 if (je->m_rate || je->t_rate) {
1192 char *tr, *mr;
1193
1194 mr = num2str(je->m_rate, 4, 0, i2p);
1195 tr = num2str(je->t_rate, 4, 0, i2p);
2f99deb0 1196 gtk_entry_set_text(GTK_ENTRY(ge->eta);
3e47bd25
JA		 1197 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1198 free(tr);
1199 free(mr);
1200 } else if (je->m_iops || je->t_iops)
1201 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
ebbd89cc 1202
2f99deb0
JA		 1203 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_bw), "---");
1204 gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---");
1205 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---");
1206 gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_iops), "---");
3e47bd25
JA		 1207#endif
1208
1209 if (je->eta_sec != INT_MAX && je->nr_running) {
1210 char *iops_str[2];
1211 char *rate_str[2];
1212
1213 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1214 strcpy(output, "-.-% done");
1215 else {
1216 eta_good = 1;
1217 perc *= 100.0;
1218 sprintf(output, "%3.1f%% done", perc);
1219 }
1220
1221 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1222 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1223
1224 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1225 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1226
2f99deb0
JA		 1227 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), rate_str[0]);
1228 gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]);
1229 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]);
1230 gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]);
3e47bd25 1231
2f99deb0
JA		 1232 graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
1233 graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
1234 graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
1235 graph_add_xy_data(ge->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
1236
1237 free(rate_str[0]);
1238 free(rate_str[1]);
1239 free(iops_str[0]);
1240 free(iops_str[1]);
1241 }
1242
1243 if (eta_str[0]) {
1244 char *dst = output + strlen(output);
1245
1246 sprintf(dst, " - %s", eta_str);
1247 }
1248
9988ca70 1249 gfio_update_thread_status(ge, output, perc);
2f99deb0
JA		 1250 gdk_threads_leave();
1251}
1252
1253/*
1254 * Update ETA in main window for all clients
1255 */
1256static void gfio_update_all_eta(struct jobs_eta *je)
1257{
1258 struct gui *ui = &main_ui;
1259 static int eta_good;
1260 char eta_str[128];
1261 char output[256];
1262 double perc = 0.0;
1263 int i2p = 0;
1264
1265 gdk_threads_enter();
1266
1267 eta_str[0] = '\0';
1268 output[0] = '\0';
1269
1270 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1271 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1272 eta_to_str(eta_str, je->eta_sec);
1273 }
1274
1275#if 0
1276 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1277 if (je->m_rate || je->t_rate) {
1278 char *tr, *mr;
1279
1280 mr = num2str(je->m_rate, 4, 0, i2p);
1281 tr = num2str(je->t_rate, 4, 0, i2p);
1282 gtk_entry_set_text(GTK_ENTRY(ui->eta);
1283 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1284 free(tr);
1285 free(mr);
1286 } else if (je->m_iops || je->t_iops)
1287 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
1288
1289 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_bw), "---");
1290 gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_iops), "---");
1291 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_bw), "---");
1292 gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_iops), "---");
1293#endif
1294
3863d1ad
JA		 1295 entry_set_int_value(ui->eta.jobs, je->nr_running);
1296
2f99deb0
JA		 1297 if (je->eta_sec != INT_MAX && je->nr_running) {
1298 char *iops_str[2];
1299 char *rate_str[2];
1300
1301 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1302 strcpy(output, "-.-% done");
1303 else {
1304 eta_good = 1;
1305 perc *= 100.0;
1306 sprintf(output, "%3.1f%% done", perc);
1307 }
1308
1309 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1310 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1311
1312 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1313 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1314
1315 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), rate_str[0]);
1316 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), iops_str[0]);
1317 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), rate_str[1]);
1318 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), iops_str[1]);
1319
1320 graph_add_xy_data(ui->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
1321 graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
1322 graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
1323 graph_add_xy_data(ui->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
2fd3bb0e 1324
3e47bd25
JA		 1325 free(rate_str[0]);
1326 free(rate_str[1]);
1327 free(iops_str[0]);
1328 free(iops_str[1]);
1329 }
1330
1331 if (eta_str[0]) {
1332 char *dst = output + strlen(output);
1333
1334 sprintf(dst, " - %s", eta_str);
1335 }
1336
9988ca70 1337 gfio_update_thread_status_all(output, perc);
0050e5f2 1338 gdk_threads_leave();
3e47bd25
JA		 1339}
1340
a1820207
SC		 1341static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1342{
843ad237 1343 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
88f6e7ad 1344 struct gfio_client *gc = client->client_data;
2f99deb0 1345 struct gui_entry *ge = gc->ge;
843ad237
JA		 1346 const char *os, *arch;
1347 char buf[64];
1348
1349 os = fio_get_os_string(probe->os);
1350 if (!os)
1351 os = "unknown";
1352
1353 arch = fio_get_arch_string(probe->arch);
1354 if (!arch)
1355 os = "unknown";
1356
1357 if (!client->name)
1358 client->name = strdup((char *) probe->hostname);
1359
0050e5f2
JA		 1360 gdk_threads_enter();
1361
2f99deb0
JA		 1362 gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname);
1363 gtk_label_set_text(GTK_LABEL(ge->probe.os), os);
1364 gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch);
843ad237 1365 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
2f99deb0 1366 gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf);
88f6e7ad 1367
2f99deb0 1368 gfio_set_connected(ge, 1);
0050e5f2
JA		 1369
1370 gdk_threads_leave();
a1820207
SC		 1371}
1372
9988ca70
JA		 1373static void gfio_update_thread_status(struct gui_entry *ge,
1374 char *status_message, double perc)
1375{
1376 static char message[100];
1377 const char *m = message;
1378
1379 strncpy(message, status_message, sizeof(message) - 1);
1380 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m);
1381 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0);
1382 gtk_widget_queue_draw(main_ui.window);
1383}
1384
1385static void gfio_update_thread_status_all(char *status_message, double perc)
5b7573ab 1386{
2f99deb0 1387 struct gui *ui = &main_ui;
5b7573ab
SC		 1388 static char message[100];
1389 const char *m = message;
1390
1391 strncpy(message, status_message, sizeof(message) - 1);
2f99deb0
JA		 1392 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m);
1393 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0);
1394 gtk_widget_queue_draw(ui->window);
5b7573ab
SC		 1395}
1396
3ec62ec4
JA		 1397static void gfio_quit_op(struct fio_client *client)
1398{
e0681f3e 1399 struct gfio_client *gc = client->client_data;
3ec62ec4 1400
0050e5f2 1401 gdk_threads_enter();
2f99deb0 1402 gfio_set_connected(gc->ge, 0);
0050e5f2 1403 gdk_threads_leave();
3ec62ec4
JA		 1404}
1405
807f9971
JA		 1406static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1407{
1408 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
e0681f3e 1409 struct gfio_client *gc = client->client_data;
dcaeb606 1410 struct thread_options *o = &gc->o;
2f99deb0 1411 struct gui_entry *ge = gc->ge;
807f9971 1412 char tmp[8];
807f9971 1413
dcaeb606 1414 convert_thread_options_to_cpu(o, &p->top);
807f9971 1415
0050e5f2
JA		 1416 gdk_threads_enter();
1417
2f99deb0
JA		 1418 gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name);
1419
3863d1ad
JA		 1420 gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name);
1421 gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0);
1422
2f99deb0
JA		 1423 gtk_entry_set_text(GTK_ENTRY(ge->eta.iotype), ddir_str(o->td_ddir));
1424 gtk_entry_set_text(GTK_ENTRY(ge->eta.ioengine), (gchar *) o->ioengine);
807f9971 1425
dcaeb606 1426 sprintf(tmp, "%u", o->iodepth);
2f99deb0 1427 gtk_entry_set_text(GTK_ENTRY(ge->eta.iodepth), tmp);
0050e5f2 1428
dcaeb606
JA		 1429 gc->job_added++;
1430
0050e5f2 1431 gdk_threads_leave();
807f9971
JA		 1432}
1433
ed727a46
JA		 1434static void gfio_client_timed_out(struct fio_client *client)
1435{
e0681f3e 1436 struct gfio_client *gc = client->client_data;
ed727a46
JA		 1437 GtkWidget *dialog, *label, *content;
1438 char buf[256];
1439
1440 gdk_threads_enter();
1441
2f99deb0
JA		 1442 gfio_set_connected(gc->ge, 0);
1443 clear_ge_ui_info(gc->ge);
ed727a46
JA		 1444
1445 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1446
1447 dialog = gtk_dialog_new_with_buttons("Timed out!",
2f99deb0 1448 GTK_WINDOW(main_ui.window),
ed727a46
JA		 1449 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1450 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
1451
f129909e
JA		 1452 /* gtk_dialog_get_content_area() is 2.14 and newer */
1453 content = GTK_DIALOG(dialog)->vbox;
1454
ed727a46
JA		 1455 label = gtk_label_new((const gchar *) buf);
1456 gtk_container_add(GTK_CONTAINER(content), label);
1457 gtk_widget_show_all(dialog);
1458 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1459
1460 gtk_dialog_run(GTK_DIALOG(dialog));
1461 gtk_widget_destroy(dialog);
1462
1463 gdk_threads_leave();
1464}
1465
6b79c80c
JA		 1466static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd)
1467{
1468 struct gfio_client *gc = client->client_data;
1469
1470 gdk_threads_enter();
1471
2f99deb0 1472 gfio_set_connected(gc->ge, 0);
6b79c80c
JA		 1473
1474 if (gc->err_entry)
1475 entry_set_int_value(gc->err_entry, client->error);
1476
1477 gdk_threads_leave();
1478}
1479
a1820207 1480struct client_ops gfio_client_ops = {
0420ba6a
JA		 1481 .text_op = gfio_text_op,
1482 .disk_util = gfio_disk_util_op,
1483 .thread_status = gfio_thread_status_op,
1484 .group_stats = gfio_group_stats_op,
2f99deb0
JA		 1485 .jobs_eta = gfio_update_client_eta,
1486 .eta = gfio_update_all_eta,
0420ba6a 1487 .probe = gfio_probe_op,
3ec62ec4 1488 .quit = gfio_quit_op,
807f9971 1489 .add_job = gfio_add_job_op,
ed727a46 1490 .timed_out = gfio_client_timed_out,
6b79c80c 1491 .stop = gfio_client_stop,
6433ee05 1492 .eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
3ec62ec4 1493 .stay_connected = 1,
a1820207
SC		 1494};
1495
ff1f3280
SC		 1496static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1497 __attribute__((unused)) gpointer data)
1498{
1499 gtk_main_quit();
1500}
1501
25927259
SC		 1502static void *job_thread(void *arg)
1503{
a9eccde4
JA		 1504 struct gui *ui = arg;
1505
1506 ui->handler_running = 1;
25927259 1507 fio_handle_clients(&gfio_client_ops);
a9eccde4 1508 ui->handler_running = 0;
25927259
SC		 1509 return NULL;
1510}
1511
2f99deb0 1512static int send_job_files(struct gui_entry *ge)
60f6b330 1513{
9988ca70 1514 struct gfio_client *gc = ge->client;
441013b4 1515 int i, ret = 0;
0420ba6a 1516
2f99deb0 1517 for (i = 0; i < ge->nr_job_files; i++) {
9988ca70 1518 ret = fio_client_send_ini(gc->client, ge->job_files[i]);
c724926b
JA		 1519 if (ret < 0) {
1520 GError *error;
1521
1522 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret));
1523 report_error(error);
1524 g_error_free(error);
1525 break;
1526 } else if (ret)
441013b4
JA		 1527 break;
1528
2f99deb0
JA		 1529 free(ge->job_files[i]);
1530 ge->job_files[i] = NULL;
441013b4 1531 }
2f99deb0
JA		 1532 while (i < ge->nr_job_files) {
1533 free(ge->job_files[i]);
1534 ge->job_files[i] = NULL;
441013b4 1535 i++;
0420ba6a
JA		 1536 }
1537
441013b4 1538 return ret;
60f6b330
SC		 1539}
1540
63a130b7
JA		 1541static void *server_thread(void *arg)
1542{
1543 is_backend = 1;
1544 gfio_server_running = 1;
1545 fio_start_server(NULL);
1546 gfio_server_running = 0;
1547 return NULL;
1548}
1549
2f99deb0 1550static void gfio_start_server(void)
63a130b7 1551{
2f99deb0
JA		 1552 struct gui *ui = &main_ui;
1553
63a130b7
JA		 1554 if (!gfio_server_running) {
1555 gfio_server_running = 1;
1556 pthread_create(&ui->server_t, NULL, server_thread, NULL);
e34f6ad7 1557 pthread_detach(ui->server_t);
63a130b7
JA		 1558 }
1559}
1560
f3074008 1561static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
25927259 1562 gpointer data)
f3074008 1563{
2f99deb0
JA		 1564 struct gui_entry *ge = data;
1565 struct gfio_client *gc = ge->client;
25927259 1566
2f99deb0
JA		 1567 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
1568 fio_start_client(gc->client);
f3074008
SC		 1569}
1570
df06f220
JA		 1571static void file_open(GtkWidget *w, gpointer data);
1572
1573static void connect_clicked(GtkWidget *widget, gpointer data)
3e47bd25 1574{
2f99deb0
JA		 1575 struct gui_entry *ge = data;
1576 struct gfio_client *gc = ge->client;
3ec62ec4 1577
2f99deb0 1578 if (!ge->connected) {
c724926b
JA		 1579 int ret;
1580
2f99deb0 1581 if (!ge->nr_job_files)
df06f220 1582 file_open(widget, data);
2f99deb0
JA		 1583 if (!ge->nr_job_files)
1584 return;
1585
1586 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
1587 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
c724926b
JA		 1588 ret = fio_client_connect(gc->client);
1589 if (!ret) {
a9eccde4
JA		 1590 if (!ge->ui->handler_running)
1591 pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
2f99deb0
JA		 1592 gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 0);
1593 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 1);
c724926b
JA		 1594 } else {
1595 GError *error;
1596
1597 error = g_error_new(g_quark_from_string("fio"), 1, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
1598 report_error(error);
1599 g_error_free(error);
69406b92 1600 }
df06f220 1601 } else {
2f99deb0
JA		 1602 fio_client_terminate(gc->client);
1603 gfio_set_connected(ge, 0);
1604 clear_ge_ui_info(ge);
df06f220 1605 }
3e47bd25
JA		 1606}
1607
b9d2f30a
JA		 1608static void send_clicked(GtkWidget *widget, gpointer data)
1609{
2f99deb0 1610 struct gui_entry *ge = data;
b9d2f30a 1611
2f99deb0 1612 if (send_job_files(ge)) {
c724926b
JA		 1613 GError *error;
1614
1615 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);
1616 report_error(error);
1617 g_error_free(error);
1618
2f99deb0 1619 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
b9d2f30a
JA		 1620 }
1621
2f99deb0
JA		 1622 gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 0);
1623 gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
b9d2f30a
JA		 1624}
1625
2f99deb0
JA		 1626static GtkWidget *add_button(GtkWidget *buttonbox,
1627 struct button_spec *buttonspec, gpointer data)
f3074008 1628{
2f99deb0
JA		 1629 GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
1630
1631 g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
1632 gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
1633 gtk_widget_set_tooltip_text(button, buttonspec->tooltiptext);
1634 gtk_widget_set_sensitive(button, !buttonspec->start_insensitive);
1635
1636 return button;
f3074008
SC		 1637}
1638
2f99deb0
JA		 1639static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
1640 int nbuttons)
f3074008
SC		 1641{
1642 int i;
1643
f3074008 1644 for (i = 0; i < nbuttons; i++)
2f99deb0 1645 ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
f3074008
SC		 1646}
1647
0420ba6a
JA		 1648static void on_info_bar_response(GtkWidget *widget, gint response,
1649 gpointer data)
1650{
2f99deb0
JA		 1651 struct gui *ui = &main_ui;
1652
0420ba6a
JA		 1653 if (response == GTK_RESPONSE_OK) {
1654 gtk_widget_destroy(widget);
2f99deb0 1655 ui->error_info_bar = NULL;
0420ba6a
JA		 1656 }
1657}
1658
df06f220 1659void report_error(GError *error)
0420ba6a 1660{
2f99deb0
JA		 1661 struct gui *ui = &main_ui;
1662
1663 if (ui->error_info_bar == NULL) {
1664 ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
0420ba6a
JA		 1665 GTK_RESPONSE_OK,
1666 NULL);
2f99deb0
JA		 1667 g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1668 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar),
0420ba6a
JA		 1669 GTK_MESSAGE_ERROR);
1670
2f99deb0
JA		 1671 ui->error_label = gtk_label_new(error->message);
1672 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar));
1673 gtk_container_add(GTK_CONTAINER(container), ui->error_label);
0420ba6a 1674
2f99deb0
JA		 1675 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0);
1676 gtk_widget_show_all(ui->vbox);
0420ba6a
JA		 1677 } else {
1678 char buffer[256];
1679 snprintf(buffer, sizeof(buffer), "Failed to open file.");
2f99deb0 1680 gtk_label_set(GTK_LABEL(ui->error_label), buffer);
0420ba6a
JA		 1681 }
1682}
1683
62bc937f
JA		 1684struct connection_widgets
1685{
1686 GtkWidget *hentry;
1687 GtkWidget *combo;
1688 GtkWidget *button;
1689};
1690
1691static void hostname_cb(GtkEntry *entry, gpointer data)
1692{
1693 struct connection_widgets *cw = data;
1694 int uses_net = 0, is_localhost = 0;
1695 const gchar *text;
1696 gchar *ctext;
1697
1698 /*
1699 * Check whether to display the 'auto start backend' box
1700 * or not. Show it if we are a localhost and using network,
1701 * or using a socket.
1702 */
1703 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1704 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1705 uses_net = 1;
1706 g_free(ctext);
1707
1708 if (uses_net) {
1709 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1710 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1711 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1712 !strcmp(text, "ip6-loopback"))
1713 is_localhost = 1;
1714 }
1715
1716 if (!uses_net || is_localhost) {
1717 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1718 gtk_widget_set_sensitive(cw->button, 1);
1719 } else {
1720 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1721 gtk_widget_set_sensitive(cw->button, 0);
1722 }
1723}
1724
b9f3c7ed
JA		 1725static int get_connection_details(char **host, int *port, int *type,
1726 int *server_start)
a7a42ce1 1727{
62bc937f
JA		 1728 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1729 struct connection_widgets cw;
a7a42ce1
JA		 1730 char *typeentry;
1731
1732 dialog = gtk_dialog_new_with_buttons("Connection details",
2f99deb0 1733 GTK_WINDOW(main_ui.window),
a7a42ce1
JA		 1734 GTK_DIALOG_DESTROY_WITH_PARENT,
1735 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1736 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1737
1738 frame = gtk_frame_new("Hostname / socket name");
f129909e
JA		 1739 /* gtk_dialog_get_content_area() is 2.14 and newer */
1740 vbox = GTK_DIALOG(dialog)->vbox;
a7a42ce1
JA		 1741 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1742
1743 box = gtk_vbox_new(FALSE, 6);
1744 gtk_container_add(GTK_CONTAINER(frame), box);
1745
1746 hbox = gtk_hbox_new(TRUE, 10);
1747 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
62bc937f
JA		 1748 cw.hentry = gtk_entry_new();
1749 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
1750 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
a7a42ce1
JA		 1751
1752 frame = gtk_frame_new("Port");
1753 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1754 box = gtk_vbox_new(FALSE, 10);
1755 gtk_container_add(GTK_CONTAINER(frame), box);
1756
1757 hbox = gtk_hbox_new(TRUE, 4);
1758 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1759 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1760
1761 frame = gtk_frame_new("Type");
1762 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1763 box = gtk_vbox_new(FALSE, 10);
1764 gtk_container_add(GTK_CONTAINER(frame), box);
1765
1766 hbox = gtk_hbox_new(TRUE, 4);
1767 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1768
62bc937f
JA		 1769 cw.combo = gtk_combo_box_new_text();
1770 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
1771 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
1772 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
1773 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
a7a42ce1 1774
62bc937f 1775 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
a7a42ce1 1776
b9f3c7ed
JA		 1777 frame = gtk_frame_new("Options");
1778 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1779 box = gtk_vbox_new(FALSE, 10);
1780 gtk_container_add(GTK_CONTAINER(frame), box);
1781
1782 hbox = gtk_hbox_new(TRUE, 4);
1783 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1784
62bc937f
JA		 1785 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1786 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
1787 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.");
1788 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
1789
1790 /*
1791 * Connect edit signal, so we can show/not-show the auto start button
1792 */
1793 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
1794 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
b9f3c7ed 1795
a7a42ce1
JA		 1796 gtk_widget_show_all(dialog);
1797
1798 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1799 gtk_widget_destroy(dialog);
1800 return 1;
1801 }
1802
62bc937f 1803 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
a7a42ce1
JA		 1804 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1805
62bc937f 1806 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
a7a42ce1
JA		 1807 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1808 *type = Fio_client_ipv4;
1809 else if (!strncmp(typeentry, "IPv6", 4))
1810 *type = Fio_client_ipv6;
1811 else
1812 *type = Fio_client_socket;
1813 g_free(typeentry);
1814
62bc937f 1815 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
b9f3c7ed 1816
a7a42ce1
JA		 1817 gtk_widget_destroy(dialog);
1818 return 0;
1819}
1820
2f99deb0 1821static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
e0681f3e
JA		 1822{
1823 struct gfio_client *gc;
1824
1825 gc = malloc(sizeof(*gc));
1826 memset(gc, 0, sizeof(*gc));
2f99deb0 1827 gc->ge = ge;
343cb4a9 1828 gc->client = fio_get_client(client);
b9d2f30a 1829
2f99deb0 1830 ge->client = gc;
e0681f3e
JA		 1831
1832 client->client_data = gc;
1833}
1834
2f99deb0
JA		 1835static GtkWidget *new_client_page(struct gui_entry *ge);
1836
1837static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
1838{
1839 struct gui_entry *ge;
1840
1841 ge = malloc(sizeof(*ge));
1842 memset(ge, 0, sizeof(*ge));
1843 INIT_FLIST_HEAD(&ge->list);
1844 flist_add_tail(&ge->list, &ui->list);
1845 ge->ui = ui;
1846 return ge;
1847}
1848
1849/*
1850 * FIXME: need more handling here
1851 */
1852static void ge_destroy(GtkWidget *w, gpointer data)
1853{
1854 struct gui_entry *ge = data;
343cb4a9
JA		 1855 struct gfio_client *gc = ge->client;
1856
1857 if (gc->client)
1858 fio_put_client(gc->client);
2f99deb0
JA		 1859
1860 flist_del(&ge->list);
1861 free(ge);
1862}
1863
1864static struct gui_entry *get_new_ge_with_tab(const char *name)
1865{
1866 struct gui_entry *ge;
1867
1868 ge = alloc_new_gui_entry(&main_ui);
1869
1870 ge->vbox = new_client_page(ge);
1871 g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_destroy), ge);
1872
1873 ge->page_label = gtk_label_new(name);
1874 ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label);
1875
1876 gtk_widget_show_all(main_ui.window);
1877 return ge;
1878}
1879
1880static void file_new(GtkWidget *w, gpointer data)
1881{
1882 get_new_ge_with_tab("Untitled");
1883}
1884
1885/*
1886 * Return the 'ge' corresponding to the tab. If the active tab is the
1887 * main tab, open a new tab.
1888 */
1889static struct gui_entry *get_ge_from_page(unsigned int cur_page)
1890{
1891 struct flist_head *entry;
1892 struct gui_entry *ge;
1893
1894 if (!cur_page)
1895 return get_new_ge_with_tab("Untitled");
1896
1897 flist_for_each(entry, &main_ui.list) {
1898 ge = flist_entry(entry, struct gui_entry, list);
1899 if (ge->page_num == cur_page)
1900 return ge;
1901 }
1902
1903 return NULL;
1904}
1905
0420ba6a
JA		 1906static void file_open(GtkWidget *w, gpointer data)
1907{
63a130b7 1908 struct gui *ui = data;
2f99deb0 1909 GtkWidget *dialog;
0420ba6a
JA		 1910 GSList *filenames, *fn_glist;
1911 GtkFileFilter *filter;
a7a42ce1 1912 char *host;
b9f3c7ed 1913 int port, type, server_start;
2f99deb0
JA		 1914 struct gui_entry *ge;
1915 gint cur_page;
1916
1917 /*
1918 * Creates new tab if current tab is the main window, or the
1919 * current tab already has a client.
1920 */
1921 cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
1922 ge = get_ge_from_page(cur_page);
1923 if (ge->client)
1924 ge = get_new_ge_with_tab("Untitled");
1925
1926 gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
0420ba6a
JA		 1927
1928 dialog = gtk_file_chooser_dialog_new("Open File",
63a130b7 1929 GTK_WINDOW(ui->window),
0420ba6a
JA		 1930 GTK_FILE_CHOOSER_ACTION_OPEN,
1931 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1932 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1933 NULL);
1934 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1935
1936 filter = gtk_file_filter_new();
1937 gtk_file_filter_add_pattern(filter, "*.fio");
1938 gtk_file_filter_add_pattern(filter, "*.job");
2d262990 1939 gtk_file_filter_add_pattern(filter, "*.ini");
0420ba6a
JA		 1940 gtk_file_filter_add_mime_type(filter, "text/fio");
1941 gtk_file_filter_set_name(filter, "Fio job file");
1942 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1943
1944 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1945 gtk_widget_destroy(dialog);
1946 return;
1947 }
1948
1949 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
a7a42ce1
JA		 1950
1951 gtk_widget_destroy(dialog);
1952
b9f3c7ed 1953 if (get_connection_details(&host, &port, &type, &server_start))
a7a42ce1
JA		 1954 goto err;
1955
0420ba6a
JA		 1956 filenames = fn_glist;
1957 while (filenames != NULL) {
e0681f3e
JA		 1958 struct fio_client *client;
1959
2f99deb0
JA		 1960 ge->job_files = realloc(ge->job_files, (ge->nr_job_files + 1) * sizeof(char *));
1961 ge->job_files[ge->nr_job_files] = strdup(filenames->data);
1962 ge->nr_job_files++;
0420ba6a 1963
e0681f3e
JA		 1964 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
1965 if (!client) {
df06f220
JA		 1966 GError *error;
1967
1968 error = g_error_new(g_quark_from_string("fio"), 1,
1969 "Failed to add client %s", host);
0420ba6a
JA		 1970 report_error(error);
1971 g_error_free(error);
0420ba6a 1972 }
2f99deb0 1973 gfio_client_added(ge, client);
0420ba6a
JA		 1974
1975 g_free(filenames->data);
1976 filenames = g_slist_next(filenames);
1977 }
a7a42ce1 1978 free(host);
63a130b7
JA		 1979
1980 if (server_start)
2f99deb0 1981 gfio_start_server();
a7a42ce1 1982err:
0420ba6a 1983 g_slist_free(fn_glist);
0420ba6a
JA		 1984}
1985
1986static void file_save(GtkWidget *w, gpointer data)
1987{
63a130b7 1988 struct gui *ui = data;
0420ba6a
JA		 1989 GtkWidget *dialog;
1990
1991 dialog = gtk_file_chooser_dialog_new("Save File",
63a130b7 1992 GTK_WINDOW(ui->window),
0420ba6a
JA		 1993 GTK_FILE_CHOOSER_ACTION_SAVE,
1994 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1995 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1996 NULL);
1997
1998 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1999 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
2000
2001 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
2002 char *filename;
2003
2004 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
2005 // save_job_file(filename);
2006 g_free(filename);
2007 }
2008 gtk_widget_destroy(dialog);
2009}
2010
9b260bdf
JA		 2011static void view_log_destroy(GtkWidget *w, gpointer data)
2012{
2013 struct gui *ui = (struct gui *) data;
2014
2015 gtk_widget_ref(ui->log_tree);
2016 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
2017 gtk_widget_destroy(w);
4cbe7211 2018 ui->log_view = NULL;
9b260bdf
JA		 2019}
2020
2021static void view_log(GtkWidget *w, gpointer data)
2022{
4cbe7211
JA		 2023 GtkWidget *win, *scroll, *vbox, *box;
2024 struct gui *ui = (struct gui *) data;
9b260bdf 2025
4cbe7211
JA		 2026 if (ui->log_view)
2027 return;
2028
2029 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
9b260bdf 2030 gtk_window_set_title(GTK_WINDOW(win), "Log");
4cbe7211 2031 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
9b260bdf 2032
4cbe7211
JA		 2033 scroll = gtk_scrolled_window_new(NULL, NULL);
2034
2035 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
2036
2037 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2038
2039 box = gtk_hbox_new(TRUE, 0);
2040 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
2041 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
2042 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
2043
2044 vbox = gtk_vbox_new(TRUE, 5);
2045 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
9b260bdf 2046
4cbe7211 2047 gtk_container_add(GTK_CONTAINER(win), vbox);
9b260bdf
JA		 2048 gtk_widget_show_all(win);
2049}
2050
8577f4fd
JA		 2051static void __update_graph_limits(struct gfio_graphs *g)
2052{
2053 line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
2054 line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
2055}
2056
2057static void update_graph_limits(void)
2058{
2059 struct flist_head *entry;
2060 struct gui_entry *ge;
2061
2062 __update_graph_limits(&main_ui.graphs);
2063
2064 flist_for_each(entry, &main_ui.list) {
2065 ge = flist_entry(entry, struct gui_entry, list);
2066 __update_graph_limits(&ge->graphs);
2067 }
2068}
2069
46974a7d
JA		 2070static void preferences(GtkWidget *w, gpointer data)
2071{
f3e8440f 2072 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
1cf6bca5 2073 GtkWidget *hbox, *spin, *entry, *spin_int;
46974a7d
JA		 2074 int i;
2075
2076 dialog = gtk_dialog_new_with_buttons("Preferences",
2f99deb0 2077 GTK_WINDOW(main_ui.window),
46974a7d
JA		 2078 GTK_DIALOG_DESTROY_WITH_PARENT,
2079 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
2080 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
2081 NULL);
2082
8577f4fd 2083 frame = gtk_frame_new("Graphing");
f3e8440f
JA		 2084 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2085 vbox = gtk_vbox_new(FALSE, 6);
2086 gtk_container_add(GTK_CONTAINER(frame), vbox);
2087
1cf6bca5
JA		 2088 hbox = gtk_hbox_new(FALSE, 5);
2089 gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
2090 entry = gtk_label_new("Font face to use for graph labels");
2091 gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
2092
f3e8440f 2093 font = gtk_font_button_new();
1cf6bca5 2094 gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
f3e8440f 2095
8577f4fd
JA		 2096 box = gtk_vbox_new(FALSE, 6);
2097 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2098
2099 hbox = gtk_hbox_new(FALSE, 5);
1cf6bca5 2100 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
8577f4fd
JA		 2101 entry = gtk_label_new("Maximum number of data points in graph (seconds)");
2102 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2103
c05d9056 2104 spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
8577f4fd 2105
1cf6bca5
JA		 2106 box = gtk_vbox_new(FALSE, 6);
2107 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
2108
2109 hbox = gtk_hbox_new(FALSE, 5);
2110 gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
2111 entry = gtk_label_new("Client ETA request interval (msec)");
2112 gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
2113
2114 spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
a31d9fa4
JA		 2115 frame = gtk_frame_new("Debug logging");
2116 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
2117 vbox = gtk_vbox_new(FALSE, 6);
2118 gtk_container_add(GTK_CONTAINER(frame), vbox);
2119
2120 box = gtk_hbox_new(FALSE, 6);
2121 gtk_container_add(GTK_CONTAINER(vbox), box);
2122
2123 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
2124
2125 for (i = 0; i < FD_DEBUG_MAX; i++) {
2126 if (i == 7) {
2127 box = gtk_hbox_new(FALSE, 6);
2128 gtk_container_add(GTK_CONTAINER(vbox), box);
2129 }
2130
2131
2132 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
2133 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
2134 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
2135 }
2136
46974a7d
JA		 2137 gtk_widget_show_all(dialog);
2138
2139 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
2140 gtk_widget_destroy(dialog);
2141 return;
2142 }
2143
2144 for (i = 0; i < FD_DEBUG_MAX; i++) {
2145 int set;
2146
2147 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
2148 if (set)
2149 fio_debug |= (1UL << i);
2150 }
2151
f3e8440f 2152 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
8577f4fd
JA		 2153 gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
2154 update_graph_limits();
1cf6bca5 2155 gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
8577f4fd 2156
46974a7d
JA		 2157 gtk_widget_destroy(dialog);
2158}
2159
0420ba6a
JA		 2160static void about_dialog(GtkWidget *w, gpointer data)
2161{
81e4ea6e
JA		 2162 const char *authors[] = {
2163 "Jens Axboe <axboe@kernel.dk>",
2164 "Stephen Carmeron <stephenmcameron@gmail.com>",
2165 NULL
2166 };
84a72ed3
JA		 2167 const char *license[] = {
2168 "Fio is free software; you can redistribute it and/or modify "
2169 "it under the terms of the GNU General Public License as published by "
2170 "the Free Software Foundation; either version 2 of the License, or "
2171 "(at your option) any later version.\n",
2172 "Fio is distributed in the hope that it will be useful, "
2173 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
2174 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
2175 "GNU General Public License for more details.\n",
2176 "You should have received a copy of the GNU General Public License "
2177 "along with Fio; if not, write to the Free Software Foundation, Inc., "
2178 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
2179 };
2180 char *license_trans;
2181
2182 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
2183 license[2], "\n", NULL);
81e4ea6e 2184
0420ba6a
JA		 2185 gtk_show_about_dialog(NULL,
2186 "program-name", "gfio",
2187 "comments", "Gtk2 UI for fio",
84a72ed3 2188 "license", license_trans,
81e4ea6e
JA		 2189 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
2190 "authors", authors,
0420ba6a 2191 "version", fio_version_string,
81e4ea6e 2192 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
0420ba6a
JA		 2193 "logo-icon-name", "fio",
2194 /* Must be last: */
81e4ea6e 2195 "wrap-license", TRUE,
0420ba6a 2196 NULL);
84a72ed3 2197
2f99deb0 2198 g_free(license_trans);
0420ba6a
JA		 2199}
2200
2201static GtkActionEntry menu_items[] = {
46974a7d 2202 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
9b260bdf 2203 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
46974a7d 2204 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
2f99deb0 2205 { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
46974a7d
JA		 2206 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
2207 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
2208 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
9b260bdf 2209 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
46974a7d
JA		 2210 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
2211 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
0420ba6a 2212};
3e47bd25 2213static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
0420ba6a
JA		 2214
2215static const gchar *ui_string = " \
2216 <ui> \
2217 <menubar name=\"MainMenu\"> \
2218 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
2f99deb0
JA		 2219 <menuitem name=\"New\" action=\"NewFile\" /> \
2220 <separator name=\"Separator1\"/> \
0420ba6a
JA		 2221 <menuitem name=\"Open\" action=\"OpenFile\" /> \
2222 <menuitem name=\"Save\" action=\"SaveFile\" /> \
46974a7d 2223 <separator name=\"Separator2\"/> \
2f99deb0
JA		 2224 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
2225 <separator name=\"Separator3\"/> \
0420ba6a
JA		 2226 <menuitem name=\"Quit\" action=\"Quit\" /> \
2227 </menu> \
9b260bdf
JA		 2228 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
2229 <menuitem name=\"Log\" action=\"ViewLog\" /> \
2230 </menu>\
0420ba6a
JA		 2231 <menu name=\"Help\" action=\"HelpMenuAction\"> \
2232 <menuitem name=\"About\" action=\"About\" /> \
2233 </menu> \
2234 </menubar> \
2235 </ui> \
2236";
2237
4cbe7211
JA		 2238static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
2239 struct gui *ui)
0420ba6a
JA		 2240{
2241 GtkActionGroup *action_group = gtk_action_group_new("Menu");
2242 GError *error = 0;
2243
2244 action_group = gtk_action_group_new("Menu");
4cbe7211 2245 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
0420ba6a
JA		 2246
2247 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
2248 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
2249
2250 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
2251 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
2252}
2253
2254void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
2255 GtkWidget *vbox, GtkUIManager *ui_manager)
2256{
2257 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
2258}
2259
2f99deb0 2260static GtkWidget *new_client_page(struct gui_entry *ge)
ff1f3280 2261{
2f99deb0 2262 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
aaa71f68 2263 GdkColor white;
0420ba6a 2264
2f99deb0 2265 main_vbox = gtk_vbox_new(FALSE, 3);
45032dd8 2266
2f99deb0
JA		 2267 ge->topalign = gtk_alignment_new(0, 0, 1, 0);
2268 ge->topvbox = gtk_vbox_new(FALSE, 3);
2269 gtk_container_add(GTK_CONTAINER(ge->topalign), ge->topvbox);
2270 gtk_box_pack_start(GTK_BOX(main_vbox), ge->topalign, FALSE, FALSE, 0);
2271
2272 probe = gtk_frame_new("Job");
2273 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
2274 probe_frame = gtk_vbox_new(FALSE, 3);
2275 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2276
2277 probe_box = gtk_hbox_new(FALSE, 3);
2278 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2279 ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
2280 ge->probe.os = new_info_label_in_frame(probe_box, "OS");
2281 ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
2282 ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
2283
2284 probe_box = gtk_hbox_new(FALSE, 3);
2285 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2286
3863d1ad 2287 ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
2f99deb0
JA		 2288 ge->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
2289 ge->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
2290 ge->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
2291 ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
2292 ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
2293
2294 probe_box = gtk_hbox_new(FALSE, 3);
2295 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
2296 ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2297 ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2298 ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2299 ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
2300
2301 /*
2302 * Only add this if we have a commit rate
2839f0c6 2303 */
2f99deb0
JA		 2304#if 0
2305 probe_box = gtk_hbox_new(FALSE, 3);
2306 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
2839f0c6 2307
2f99deb0
JA		 2308 ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2309 ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
ff1f3280 2310
2f99deb0
JA		 2311 ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2312 ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2313#endif
ff1f3280 2314
2f99deb0
JA		 2315 /*
2316 * Set up a drawing area and IOPS and bandwidth graphs
2317 */
2318 gdk_color_parse("white", &white);
2319 ge->graphs.drawing_area = gtk_drawing_area_new();
2f99deb0 2320 gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
57f9d28e 2321 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2f99deb0
JA		 2322 gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2323 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event",
2324 G_CALLBACK(on_expose_drawing_area), &ge->graphs);
2325 g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
2326 G_CALLBACK(on_config_drawing_area), &ge->graphs);
2327 ge->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2328 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ge->scrolled_window),
2329 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2330 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ge->scrolled_window),
2331 ge->graphs.drawing_area);
2332 gtk_box_pack_start(GTK_BOX(main_vbox), ge->scrolled_window,
2333 TRUE, TRUE, 0);
04cc6b77 2334
2f99deb0
JA		 2335 setup_graphs(&ge->graphs);
2336
2337 /*
2338 * Set up alignments for widgets at the bottom of ui,
2339 * align bottom left, expand horizontally but not vertically
2340 */
2341 ge->bottomalign = gtk_alignment_new(0, 1, 1, 0);
2342 ge->buttonbox = gtk_hbox_new(FALSE, 0);
2343 gtk_container_add(GTK_CONTAINER(ge->bottomalign), ge->buttonbox);
2344 gtk_box_pack_start(GTK_BOX(main_vbox), ge->bottomalign,
2345 FALSE, FALSE, 0);
2346
2347 add_buttons(ge, buttonspeclist, ARRAYSIZE(buttonspeclist));
0420ba6a 2348
c36f98d9 2349 /*
2f99deb0
JA		 2350 * Set up thread status progress bar
2351 */
2352 ge->thread_status_pb = gtk_progress_bar_new();
2353 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
2354 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
2355 gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
2356
2357
2358 return main_vbox;
2359}
2360
2361static GtkWidget *new_main_page(struct gui *ui)
2362{
2363 GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
2364 GdkColor white;
2365
2366 main_vbox = gtk_vbox_new(FALSE, 3);
2367
2368 /*
2369 * Set up alignments for widgets at the top of ui,
c36f98d9
SC		 2370 * align top left, expand horizontally but not vertically
2371 */
2372 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
2f99deb0 2373 ui->topvbox = gtk_vbox_new(FALSE, 0);
c36f98d9 2374 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
2f99deb0 2375 gtk_box_pack_start(GTK_BOX(main_vbox), ui->topalign, FALSE, FALSE, 0);
c36f98d9 2376
2f99deb0
JA		 2377 probe = gtk_frame_new("Run statistics");
2378 gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
843ad237
JA		 2379 probe_frame = gtk_vbox_new(FALSE, 3);
2380 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
2381
2382 probe_box = gtk_hbox_new(FALSE, 3);
2f99deb0 2383 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
3863d1ad 2384 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
ca850992
JA		 2385 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
2386 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
2387 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
2388 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
3e47bd25 2389
807f9971
JA		 2390 /*
2391 * Only add this if we have a commit rate
2392 */
2393#if 0
3e47bd25
JA		 2394 probe_box = gtk_hbox_new(FALSE, 3);
2395 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971
JA		 2396
2397 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
2398 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
2399
3e47bd25
JA		 2400 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
2401 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
807f9971 2402#endif
3e47bd25 2403
736f2dff 2404 /*
2fd3bb0e 2405 * Set up a drawing area and IOPS and bandwidth graphs
736f2dff 2406 */
aaa71f68 2407 gdk_color_parse("white", &white);
2f99deb0 2408 ui->graphs.drawing_area = gtk_drawing_area_new();
2f99deb0 2409 gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
57f9d28e 2410 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
2f99deb0
JA		 2411 gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &white);
2412 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event",
2413 G_CALLBACK(on_expose_drawing_area), &ui->graphs);
2414 g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
2415 G_CALLBACK(on_config_drawing_area), &ui->graphs);
736f2dff
SC		 2416 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
2417 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
2418 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2fd3bb0e 2419 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ui->scrolled_window),
2f99deb0
JA		 2420 ui->graphs.drawing_area);
2421 gtk_box_pack_start(GTK_BOX(main_vbox), ui->scrolled_window,
e164534f 2422 TRUE, TRUE, 0);
736f2dff 2423
2f99deb0 2424 setup_graphs(&ui->graphs);
2fd3bb0e 2425
c36f98d9
SC		 2426 /*
2427 * Set up alignments for widgets at the bottom of ui,
2428 * align bottom left, expand horizontally but not vertically
2429 */
2430 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
2431 ui->buttonbox = gtk_hbox_new(FALSE, 0);
2432 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
2f99deb0 2433 gtk_box_pack_start(GTK_BOX(main_vbox), ui->bottomalign,
e164534f 2434 FALSE, FALSE, 0);
c36f98d9 2435
3ec62ec4
JA		 2436 /*
2437 * Set up thread status progress bar
2438 */
2439 ui->thread_status_pb = gtk_progress_bar_new();
2440 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
8663ea65 2441 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
3ec62ec4
JA		 2442 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
2443
2f99deb0
JA		 2444 return main_vbox;
2445}
2446
2447static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
2448 guint page, gpointer data)
2449
2450{
2451 return TRUE;
2452}
2453
2454static void init_ui(int *argc, char **argv[], struct gui *ui)
2455{
2456 GtkSettings *settings;
2457 GtkUIManager *uimanager;
2458 GtkWidget *menu, *vbox;
2459
2460 /* Magical g*thread incantation, you just need this thread stuff.
2461 * Without it, the update that happens in gfio_update_thread_status
2462 * doesn't really happen in a timely fashion, you need expose events
2463 */
2464 if (!g_thread_supported())
2465 g_thread_init(NULL);
2466 gdk_threads_init();
2467
2468 gtk_init(argc, argv);
2469 settings = gtk_settings_get_default();
2470 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
2471 g_type_init();
2472
2473 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
2474 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
2475 gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
2476
2477 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
2478 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
2479
2480 ui->vbox = gtk_vbox_new(FALSE, 0);
2481 gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
2482
2483 uimanager = gtk_ui_manager_new();
2484 menu = get_menubar_menu(ui->window, uimanager, ui);
2485 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
2486
2487 ui->notebook = gtk_notebook_new();
2488 g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
b870c31b 2489 gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
0aa928c4 2490 gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
2f99deb0
JA		 2491 gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
2492
2493 vbox = new_main_page(ui);
2494
2495 gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
2496
9b260bdf 2497 gfio_ui_setup_log(ui);
3ec62ec4 2498
ff1f3280
SC		 2499 gtk_widget_show_all(ui->window);
2500}
2501
8232e285 2502int main(int argc, char *argv[], char *envp[])
ff1f3280 2503{
8232e285
SC		 2504 if (initialize_fio(envp))
2505 return 1;
0420ba6a
JA		 2506 if (fio_init_options())
2507 return 1;
a1820207 2508
2f99deb0
JA		 2509 memset(&main_ui, 0, sizeof(main_ui));
2510 INIT_FLIST_HEAD(&main_ui.list);
2511
2512 init_ui(&argc, &argv, &main_ui);
5b7573ab 2513
2839f0c6 2514 gdk_threads_enter();
ff1f3280 2515 gtk_main();
2839f0c6 2516 gdk_threads_leave();
ff1f3280
SC		 2517 return 0;
2518}
fio - Flexible IO Tester