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