projects / fio.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gfio: make empty graph show grid lines, not "No good data"
[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>
8232e285 26
5b7573ab 27#include <glib.h>
2fd3bb0e 28#include <cairo.h>
ff1f3280
SC		 29#include <gtk/gtk.h>
30
8232e285 31#include "fio.h"
2fd3bb0e 32#include "graph.h"
8232e285 33
63a130b7 34static int gfio_server_running;
f3e8440f 35static const char *gfio_graph_font;
63a130b7 36
3e47bd25
JA		 37static void gfio_update_thread_status(char *status_message, double perc);
38
f3074008
SC		 39#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
40
41typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
42
3e47bd25 43static void connect_clicked(GtkWidget *widget, gpointer data);
f3074008
SC		 44static void start_job_clicked(GtkWidget *widget, gpointer data);
45
46static struct button_spec {
47 const char *buttontext;
48 clickfunction f;
49 const char *tooltiptext;
3e47bd25 50 const int start_insensitive;
f3074008 51} buttonspeclist[] = {
3e47bd25
JA		 52#define CONNECT_BUTTON 0
53#define START_JOB_BUTTON 1
54 { "Connect", connect_clicked, "Connect to host", 0 },
f3074008
SC		 55 { "Start Job",
56 start_job_clicked,
3e47bd25 57 "Send current fio job to fio server to be executed", 1 },
f3074008
SC		 58};
59
843ad237
JA		 60struct probe_widget {
61 GtkWidget *hostname;
62 GtkWidget *os;
63 GtkWidget *arch;
64 GtkWidget *fio_ver;
65};
66
3e47bd25 67struct eta_widget {
807f9971
JA		 68 GtkWidget *name;
69 GtkWidget *iotype;
70 GtkWidget *ioengine;
71 GtkWidget *iodepth;
3e47bd25
JA		 72 GtkWidget *jobs;
73 GtkWidget *files;
74 GtkWidget *read_bw;
75 GtkWidget *read_iops;
76 GtkWidget *cr_bw;
77 GtkWidget *cr_iops;
78 GtkWidget *write_bw;
79 GtkWidget *write_iops;
80 GtkWidget *cw_bw;
81 GtkWidget *cw_iops;
82};
83
ff1f3280
SC		 84struct gui {
85 GtkWidget *window;
5b7573ab 86 GtkWidget *vbox;
c36f98d9
SC		 87 GtkWidget *topvbox;
88 GtkWidget *topalign;
89 GtkWidget *bottomalign;
04cc6b77 90 GtkWidget *thread_status_pb;
f3074008
SC		 91 GtkWidget *buttonbox;
92 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
736f2dff 93 GtkWidget *scrolled_window;
2fd3bb0e
JA		 94#define DRAWING_AREA_XDIM 1000
95#define DRAWING_AREA_YDIM 400
96 GtkWidget *drawing_area;
0420ba6a
JA		 97 GtkWidget *error_info_bar;
98 GtkWidget *error_label;
f9d40b48
JA		 99 GtkWidget *results_notebook;
100 GtkWidget *results_window;
9b260bdf
JA		 101 GtkListStore *log_model;
102 GtkWidget *log_tree;
4cbe7211 103 GtkWidget *log_view;
736f2dff 104 GtkTextBuffer *text;
843ad237 105 struct probe_widget probe;
3e47bd25 106 struct eta_widget eta;
3ec62ec4 107 int connected;
25927259 108 pthread_t t;
63a130b7 109 pthread_t server_t;
0420ba6a 110
2fd3bb0e
JA		 111 struct graph *iops_graph;
112 struct graph *bandwidth_graph;
3ec62ec4 113 struct fio_client *client;
0420ba6a
JA		 114 int nr_job_files;
115 char **job_files;
5b7573ab 116} ui;
ff1f3280 117
e0681f3e
JA		 118struct gfio_client {
119 struct gui *ui;
120 GtkWidget *results_widget;
121 GtkWidget *disk_util_frame;
122};
123
cae08727
SC		 124static void add_invisible_data(struct graph *g)
125{
126 /*
127 * This puts some invisible data into a graph so that it will
128 * initially have some grid lines instead of "No good data"
129 */
130 graph_add_label(g, "invisible");
131 graph_set_color(g, "invisible", INVISIBLE_COLOR, 0.0, 0.7);
132 graph_add_xy_data(g, "invisible", 0.0, 0.0);
133 graph_add_xy_data(g, "invisible", 1.0, 100.0);
134}
135
2fd3bb0e
JA		 136static void setup_iops_graph(struct gui *ui)
137{
138 if (ui->iops_graph)
139 graph_free(ui->iops_graph);
87d5f276 140 ui->iops_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
f3e8440f 141 DRAWING_AREA_YDIM, gfio_graph_font);
2fd3bb0e
JA		 142 graph_title(ui->iops_graph, "IOPS");
143 graph_x_title(ui->iops_graph, "Time");
144 graph_y_title(ui->iops_graph, "IOPS");
145 graph_add_label(ui->iops_graph, "Read IOPS");
146 graph_add_label(ui->iops_graph, "Write IOPS");
147 graph_set_color(ui->iops_graph, "Read IOPS", 0.7, 0.0, 0.0);
148 graph_set_color(ui->iops_graph, "Write IOPS", 0.0, 0.0, 0.7);
cae08727 149 add_invisible_data(ui->iops_graph);
2fd3bb0e
JA		 150}
151
152static void setup_bandwidth_graph(struct gui *ui)
153{
154 if (ui->bandwidth_graph)
155 graph_free(ui->bandwidth_graph);
87d5f276 156 ui->bandwidth_graph = graph_new(DRAWING_AREA_XDIM / 2.0,
f3e8440f 157 DRAWING_AREA_YDIM, gfio_graph_font);
2fd3bb0e
JA		 158 graph_title(ui->bandwidth_graph, "Bandwidth");
159 graph_x_title(ui->bandwidth_graph, "Time");
160 graph_y_title(ui->bandwidth_graph, "Bandwidth");
161 graph_add_label(ui->bandwidth_graph, "Read Bandwidth");
162 graph_add_label(ui->bandwidth_graph, "Write Bandwidth");
163 graph_set_color(ui->bandwidth_graph, "Read Bandwidth", 0.7, 0.0, 0.0);
164 graph_set_color(ui->bandwidth_graph, "Write Bandwidth", 0.0, 0.0, 0.7);
cae08727 165 add_invisible_data(ui->bandwidth_graph);
2fd3bb0e
JA		 166}
167
8663ea65
JA		 168static void clear_ui_info(struct gui *ui)
169{
170 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
171 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
172 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
173 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
ca850992
JA		 174 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
175 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
176 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
177 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
178 gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
179 gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
180 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
181 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
182 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
183 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
8663ea65
JA		 184}
185
3650a3ca
JA		 186static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
187{
188 GtkWidget *entry, *frame;
189
190 frame = gtk_frame_new(label);
191 entry = gtk_entry_new();
1c1e4a5b 192 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
3650a3ca
JA		 193 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
194 gtk_container_add(GTK_CONTAINER(frame), entry);
195
196 return entry;
197}
198
199static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
200{
201 GtkWidget *label_widget;
202 GtkWidget *frame;
203
204 frame = gtk_frame_new(label);
205 label_widget = gtk_label_new(NULL);
206 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
207 gtk_container_add(GTK_CONTAINER(frame), label_widget);
208
209 return label_widget;
210}
211
212static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
213{
214 GtkWidget *button, *box;
215
216 box = gtk_hbox_new(FALSE, 3);
217 gtk_container_add(GTK_CONTAINER(hbox), box);
218
219 button = gtk_spin_button_new_with_range(min, max, 1.0);
220 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
221
222 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
223 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
224
225 return button;
226}
227
3ec62ec4
JA		 228static void gfio_set_connected(struct gui *ui, int connected)
229{
230 if (connected) {
231 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
232 ui->connected = 1;
233 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
88f6e7ad 234 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
3ec62ec4
JA		 235 } else {
236 ui->connected = 0;
237 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
238 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
63a130b7 239 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
3ec62ec4
JA		 240 }
241}
242
3650a3ca
JA		 243static void label_set_int_value(GtkWidget *entry, unsigned int val)
244{
245 char tmp[80];
246
247 sprintf(tmp, "%u", val);
248 gtk_label_set_text(GTK_LABEL(entry), tmp);
249}
250
251static void entry_set_int_value(GtkWidget *entry, unsigned int val)
252{
253 char tmp[80];
254
255 sprintf(tmp, "%u", val);
256 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
257}
258
a269790c
JA		 259#define ALIGN_LEFT 1
260#define ALIGN_RIGHT 2
261#define INVISIBLE 4
262#define UNSORTABLE 8
263
264GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
265{
266 GtkCellRenderer *renderer;
267 GtkTreeViewColumn *col;
268 double xalign = 0.0; /* left as default */
269 PangoAlignment align;
270 gboolean visible;
271
272 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
273 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
274 PANGO_ALIGN_CENTER;
275 visible = !(flags & INVISIBLE);
276
277 renderer = gtk_cell_renderer_text_new();
278 col = gtk_tree_view_column_new();
279
280 gtk_tree_view_column_set_title(col, title);
281 if (!(flags & UNSORTABLE))
282 gtk_tree_view_column_set_sort_column_id(col, index);
283 gtk_tree_view_column_set_resizable(col, TRUE);
284 gtk_tree_view_column_pack_start(col, renderer, TRUE);
285 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
286 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
287 switch (align) {
288 case PANGO_ALIGN_LEFT:
289 xalign = 0.0;
290 break;
291 case PANGO_ALIGN_CENTER:
292 xalign = 0.5;
293 break;
294 case PANGO_ALIGN_RIGHT:
295 xalign = 1.0;
296 break;
297 }
298 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
299 gtk_tree_view_column_set_visible(col, visible);
300 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
301 return col;
302}
303
9b260bdf
JA		 304static void gfio_ui_setup_log(struct gui *ui)
305{
306 GtkTreeSelection *selection;
307 GtkListStore *model;
308 GtkWidget *tree_view;
309
310 model = gtk_list_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, G_TYPE_STRING);
311
312 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
313 gtk_widget_set_can_focus(tree_view, FALSE);
314
315 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
316 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
661f741a
JA		 317 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
318 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
9b260bdf
JA		 319
320 tree_view_column(tree_view, 0, "Time", ALIGN_RIGHT | UNSORTABLE);
321 tree_view_column(tree_view, 1, "Host", ALIGN_RIGHT | UNSORTABLE);
322 tree_view_column(tree_view, 2, "Level", ALIGN_RIGHT | UNSORTABLE);
f095d563 323 tree_view_column(tree_view, 3, "Text", ALIGN_LEFT | UNSORTABLE);
9b260bdf
JA		 324
325 ui->log_model = model;
326 ui->log_tree = tree_view;
327}
328
a269790c
JA		 329static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
330 fio_fp64_t *plist,
331 unsigned int len,
332 const char *base,
333 unsigned int scale)
334{
335 GType types[FIO_IO_U_LIST_MAX_LEN];
336 GtkWidget *tree_view;
337 GtkTreeSelection *selection;
338 GtkListStore *model;
339 GtkTreeIter iter;
340 int i;
341
342 for (i = 0; i < len; i++)
343 types[i] = G_TYPE_INT;
344
345 model = gtk_list_store_newv(len, types);
346
347 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
348 gtk_widget_set_can_focus(tree_view, FALSE);
349
661f741a
JA		 350 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
351 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
352
a269790c
JA		 353 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
354 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
355
356 for (i = 0; i < len; i++) {
357 char fbuf[8];
358
359 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
360 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
361 }
362
363 gtk_list_store_append(model, &iter);
364
e0681f3e
JA		 365 for (i = 0; i < len; i++) {
366 if (scale)
367 ovals[i] = (ovals[i] + 999) / 1000;
a269790c 368 gtk_list_store_set(model, &iter, i, ovals[i], -1);
e0681f3e 369 }
a269790c
JA		 370
371 return tree_view;
372}
373
374static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
375 int ddir)
376{
377 unsigned int *io_u_plat = ts->io_u_plat[ddir];
378 unsigned long nr = ts->clat_stat[ddir].samples;
379 fio_fp64_t *plist = ts->percentile_list;
380 unsigned int *ovals, len, minv, maxv, scale_down;
381 const char *base;
382 GtkWidget *tree_view, *frame, *hbox;
383 char tmp[64];
384
385 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
386 if (!len)
387 goto out;
388
389 /*
390 * We default to usecs, but if the value range is such that we
391 * should scale down to msecs, do that.
392 */
393 if (minv > 2000 && maxv > 99999) {
394 scale_down = 1;
395 base = "msec";
396 } else {
397 scale_down = 0;
398 base = "usec";
399 }
400
401 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
402
403 sprintf(tmp, "Completion percentiles (%s)", base);
404 frame = gtk_frame_new(tmp);
405 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
406
407 hbox = gtk_hbox_new(FALSE, 3);
408 gtk_container_add(GTK_CONTAINER(frame), hbox);
409
410 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
411out:
412 if (ovals)
413 free(ovals);
414}
415
3650a3ca
JA		 416static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
417 unsigned long max, double mean, double dev)
418{
419 const char *base = "(usec)";
1c1e4a5b 420 GtkWidget *hbox, *label, *frame;
3650a3ca
JA		 421 char *minp, *maxp;
422 char tmp[64];
423
424 if (!usec_to_msec(&min, &max, &mean, &dev))
425 base = "(msec)";
426
427 minp = num2str(min, 6, 1, 0);
428 maxp = num2str(max, 6, 1, 0);
429
3650a3ca
JA		 430 sprintf(tmp, "%s %s", name, base);
431 frame = gtk_frame_new(tmp);
432 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
433
3650a3ca 434 hbox = gtk_hbox_new(FALSE, 3);
1c1e4a5b 435 gtk_container_add(GTK_CONTAINER(frame), hbox);
3650a3ca
JA		 436
437 label = new_info_label_in_frame(hbox, "Minimum");
438 gtk_label_set_text(GTK_LABEL(label), minp);
439 label = new_info_label_in_frame(hbox, "Maximum");
440 gtk_label_set_text(GTK_LABEL(label), maxp);
441 label = new_info_label_in_frame(hbox, "Average");
442 sprintf(tmp, "%5.02f", mean);
443 gtk_label_set_text(GTK_LABEL(label), tmp);
444 label = new_info_label_in_frame(hbox, "Standard deviation");
445 sprintf(tmp, "%5.02f", dev);
446 gtk_label_set_text(GTK_LABEL(label), tmp);
447
448 free(minp);
449 free(maxp);
450
451}
452
ca850992
JA		 453#define GFIO_CLAT 1
454#define GFIO_SLAT 2
455#define GFIO_LAT 4
456
3650a3ca
JA		 457static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
458 struct thread_stat *ts, int ddir)
459{
460 const char *ddir_label[2] = { "Read", "Write" };
0b761306 461 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
e0681f3e 462 unsigned long min[3], max[3], runt;
3650a3ca 463 unsigned long long bw, iops;
ca850992 464 unsigned int flags = 0;
e0681f3e 465 double mean[3], dev[3];
3650a3ca
JA		 466 char *io_p, *bw_p, *iops_p;
467 int i2p;
468
469 if (!ts->runtime[ddir])
470 return;
471
472 i2p = is_power_of_2(rs->kb_base);
473 runt = ts->runtime[ddir];
474
475 bw = (1000 * ts->io_bytes[ddir]) / runt;
476 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
477 bw_p = num2str(bw, 6, 1, i2p);
478
479 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
480 iops_p = num2str(iops, 6, 1, 0);
481
482 box = gtk_hbox_new(FALSE, 3);
483 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
484
485 frame = gtk_frame_new(ddir_label[ddir]);
486 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
487
0b761306
JA		 488 main_vbox = gtk_vbox_new(FALSE, 3);
489 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
3650a3ca
JA		 490
491 box = gtk_hbox_new(FALSE, 3);
0b761306 492 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
3650a3ca
JA		 493
494 label = new_info_label_in_frame(box, "IO");
495 gtk_label_set_text(GTK_LABEL(label), io_p);
496 label = new_info_label_in_frame(box, "Bandwidth");
497 gtk_label_set_text(GTK_LABEL(label), bw_p);
498 label = new_info_label_in_frame(box, "IOPS");
499 gtk_label_set_text(GTK_LABEL(label), iops_p);
500 label = new_info_label_in_frame(box, "Runtime (msec)");
501 label_set_int_value(label, ts->runtime[ddir]);
502
e0681f3e 503 if (calc_lat(&ts->bw_stat[ddir], &min[0], &max[0], &mean[0], &dev[0])) {
ca850992
JA		 504 double p_of_agg = 100.0;
505 const char *bw_str = "KB";
506 char tmp[32];
507
508 if (rs->agg[ddir]) {
e0681f3e 509 p_of_agg = mean[0] * 100 / (double) rs->agg[ddir];
ca850992
JA		 510 if (p_of_agg > 100.0)
511 p_of_agg = 100.0;
512 }
513
e0681f3e
JA		 514 if (mean[0] > 999999.9) {
515 min[0] /= 1000.0;
516 max[0] /= 1000.0;
517 mean[0] /= 1000.0;
518 dev[0] /= 1000.0;
ca850992
JA		 519 bw_str = "MB";
520 }
521
0b761306
JA		 522 sprintf(tmp, "Bandwidth (%s)", bw_str);
523 frame = gtk_frame_new(tmp);
524 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
ca850992 525
0b761306
JA		 526 box = gtk_hbox_new(FALSE, 3);
527 gtk_container_add(GTK_CONTAINER(frame), box);
ca850992 528
0b761306 529 label = new_info_label_in_frame(box, "Minimum");
e0681f3e 530 label_set_int_value(label, min[0]);
0b761306 531 label = new_info_label_in_frame(box, "Maximum");
e0681f3e 532 label_set_int_value(label, max[0]);
0b761306 533 label = new_info_label_in_frame(box, "Percentage of jobs");
ca850992
JA		 534 sprintf(tmp, "%3.2f%%", p_of_agg);
535 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 536 label = new_info_label_in_frame(box, "Average");
e0681f3e 537 sprintf(tmp, "%5.02f", mean[0]);
ca850992 538 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 539 label = new_info_label_in_frame(box, "Standard deviation");
e0681f3e 540 sprintf(tmp, "%5.02f", dev[0]);
ca850992
JA		 541 gtk_label_set_text(GTK_LABEL(label), tmp);
542 }
543
e0681f3e 544 if (calc_lat(&ts->slat_stat[ddir], &min[0], &max[0], &mean[0], &dev[0]))
2b089892 545 flags |= GFIO_SLAT;
e0681f3e 546 if (calc_lat(&ts->clat_stat[ddir], &min[1], &max[1], &mean[1], &dev[1]))
2b089892 547 flags |= GFIO_CLAT;
e0681f3e 548 if (calc_lat(&ts->lat_stat[ddir], &min[2], &max[2], &mean[2], &dev[2]))
2b089892
JA		 549 flags |= GFIO_LAT;
550
551 if (flags) {
552 frame = gtk_frame_new("Latency");
553 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
554
555 vbox = gtk_vbox_new(FALSE, 3);
556 gtk_container_add(GTK_CONTAINER(frame), vbox);
557
558 if (flags & GFIO_SLAT)
e0681f3e 559 gfio_show_lat(vbox, "Submission latency", min[0], max[0], mean[0], dev[0]);
2b089892 560 if (flags & GFIO_CLAT)
e0681f3e 561 gfio_show_lat(vbox, "Completion latency", min[1], max[1], mean[1], dev[1]);
2b089892 562 if (flags & GFIO_LAT)
e0681f3e 563 gfio_show_lat(vbox, "Total latency", min[2], max[2], mean[2], dev[2]);
2b089892
JA		 564 }
565
566 if (ts->clat_percentiles)
567 gfio_show_clat_percentiles(main_vbox, ts, ddir);
568
569
3650a3ca
JA		 570 free(io_p);
571 free(bw_p);
572 free(iops_p);
573}
574
e5bd1347
JA		 575static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
576 const char **labels)
577{
578 GtkWidget *tree_view;
579 GtkTreeSelection *selection;
580 GtkListStore *model;
581 GtkTreeIter iter;
582 GType *types;
583 int i, skipped;
584
585 /*
586 * Check if all are empty, in which case don't bother
587 */
588 for (i = 0, skipped = 0; i < num; i++)
589 if (lat[i] <= 0.0)
590 skipped++;
591
592 if (skipped == num)
593 return NULL;
594
595 types = malloc(num * sizeof(GType));
596
597 for (i = 0; i < num; i++)
598 types[i] = G_TYPE_STRING;
599
600 model = gtk_list_store_newv(num, types);
601 free(types);
602 types = NULL;
603
604 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
605 gtk_widget_set_can_focus(tree_view, FALSE);
606
661f741a
JA		 607 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
608 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
609
e5bd1347
JA		 610 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
611 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
612
613 for (i = 0; i < num; i++)
614 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
615
616 gtk_list_store_append(model, &iter);
617
618 for (i = 0; i < num; i++) {
619 char fbuf[32];
620
621 if (lat[i] <= 0.0)
622 sprintf(fbuf, "0.00");
623 else
624 sprintf(fbuf, "%3.2f%%", lat[i]);
625
626 gtk_list_store_set(model, &iter, i, fbuf, -1);
627 }
628
629 return tree_view;
630}
631
632static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
633{
634 GtkWidget *box, *frame, *tree_view;
635 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
636 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
637 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
638 "250", "500", "750", "1000", };
639 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
640 "250", "500", "750", "1000", "2000",
641 ">= 2000", };
642
643 stat_calc_lat_u(ts, io_u_lat_u);
644 stat_calc_lat_m(ts, io_u_lat_m);
645
646 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
647 if (tree_view) {
648 frame = gtk_frame_new("Latency buckets (usec)");
649 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
650
651 box = gtk_hbox_new(FALSE, 3);
652 gtk_container_add(GTK_CONTAINER(frame), box);
653 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
654 }
655
656 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
657 if (tree_view) {
658 frame = gtk_frame_new("Latency buckets (msec)");
659 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
660
661 box = gtk_hbox_new(FALSE, 3);
662 gtk_container_add(GTK_CONTAINER(frame), box);
663 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
664 }
665}
666
2e33101f
JA		 667static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
668{
669 GtkWidget *box, *frame, *entry;
670 double usr_cpu, sys_cpu;
671 unsigned long runtime;
672 char tmp[32];
673
674 runtime = ts->total_run_time;
675 if (runtime) {
676 double runt = (double) runtime;
677
678 usr_cpu = (double) ts->usr_time * 100 / runt;
679 sys_cpu = (double) ts->sys_time * 100 / runt;
680 } else {
681 usr_cpu = 0;
682 sys_cpu = 0;
683 }
684
685 frame = gtk_frame_new("OS resources");
686 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
687
688 box = gtk_hbox_new(FALSE, 3);
689 gtk_container_add(GTK_CONTAINER(frame), box);
690
691 entry = new_info_entry_in_frame(box, "User CPU");
692 sprintf(tmp, "%3.2f%%", usr_cpu);
693 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
694 entry = new_info_entry_in_frame(box, "System CPU");
695 sprintf(tmp, "%3.2f%%", sys_cpu);
696 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
697 entry = new_info_entry_in_frame(box, "Context switches");
698 entry_set_int_value(entry, ts->ctx);
699 entry = new_info_entry_in_frame(box, "Major faults");
700 entry_set_int_value(entry, ts->majf);
701 entry = new_info_entry_in_frame(box, "Minor faults");
702 entry_set_int_value(entry, ts->minf);
703}
19998dbc
JA		 704static void gfio_add_sc_depths_tree(GtkListStore *model,
705 struct thread_stat *ts, unsigned int len,
706 int submit)
2e33101f
JA		 707{
708 double io_u_dist[FIO_IO_U_MAP_NR];
2e33101f 709 GtkTreeIter iter;
19998dbc
JA		 710 /* Bits 0, and 3-8 */
711 const int add_mask = 0x1f9;
712 int i, j;
2e33101f 713
19998dbc
JA		 714 if (submit)
715 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
716 else
717 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
2e33101f 718
19998dbc 719 gtk_list_store_append(model, &iter);
2e33101f 720
19998dbc 721 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
2e33101f 722
19998dbc
JA		 723 for (i = 1, j = 0; i < len; i++) {
724 char fbuf[32];
2e33101f 725
19998dbc
JA		 726 if (!(add_mask & (1UL << (i - 1))))
727 sprintf(fbuf, "0.0%%");
728 else {
729 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
730 j++;
731 }
2e33101f 732
19998dbc
JA		 733 gtk_list_store_set(model, &iter, i, fbuf, -1);
734 }
2e33101f 735
19998dbc 736}
2e33101f 737
19998dbc
JA		 738static void gfio_add_total_depths_tree(GtkListStore *model,
739 struct thread_stat *ts, unsigned int len)
740{
741 double io_u_dist[FIO_IO_U_MAP_NR];
742 GtkTreeIter iter;
743 /* Bits 1-6, and 8 */
744 const int add_mask = 0x17e;
745 int i, j;
746
747 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
2e33101f
JA		 748
749 gtk_list_store_append(model, &iter);
750
19998dbc
JA		 751 gtk_list_store_set(model, &iter, 0, "Total", -1);
752
753 for (i = 1, j = 0; i < len; i++) {
2e33101f
JA		 754 char fbuf[32];
755
19998dbc
JA		 756 if (!(add_mask & (1UL << (i - 1))))
757 sprintf(fbuf, "0.0%%");
758 else {
759 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
760 j++;
2e33101f
JA		 761 }
762
2e33101f
JA		 763 gtk_list_store_set(model, &iter, i, fbuf, -1);
764 }
765
19998dbc 766}
2e33101f 767
19998dbc
JA		 768static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
769{
770 GtkWidget *frame, *box, *tree_view;
771 GtkTreeSelection *selection;
772 GtkListStore *model;
773 GType types[FIO_IO_U_MAP_NR + 1];
774 int i;
775#define NR_LABELS 10
776 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
2e33101f 777
19998dbc
JA		 778 frame = gtk_frame_new("IO depths");
779 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2e33101f 780
19998dbc
JA		 781 box = gtk_hbox_new(FALSE, 3);
782 gtk_container_add(GTK_CONTAINER(frame), box);
2e33101f 783
19998dbc
JA		 784 for (i = 0; i < NR_LABELS; i++)
785 types[i] = G_TYPE_STRING;
2e33101f 786
19998dbc 787 model = gtk_list_store_newv(NR_LABELS, types);
2e33101f 788
19998dbc
JA		 789 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
790 gtk_widget_set_can_focus(tree_view, FALSE);
2e33101f 791
661f741a
JA		 792 g_object_set(G_OBJECT(tree_view), "headers-visible", TRUE,
793 "enable-grid-lines", GTK_TREE_VIEW_GRID_LINES_BOTH, NULL);
794
19998dbc
JA		 795 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
796 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
797
798 for (i = 0; i < NR_LABELS; i++)
799 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
800
801 gfio_add_total_depths_tree(model, ts, NR_LABELS);
802 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
803 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
2e33101f
JA		 804
805 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
806}
807
f9d40b48
JA		 808static gboolean results_window_delete(GtkWidget *w, gpointer data)
809{
810 struct gui *ui = (struct gui *) data;
811
812 gtk_widget_destroy(w);
813 ui->results_window = NULL;
814 ui->results_notebook = NULL;
815 return TRUE;
816}
817
818static GtkWidget *get_results_window(struct gui *ui)
819{
820 GtkWidget *win, *notebook;
821
822 if (ui->results_window)
823 return ui->results_notebook;
824
825 win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
826 gtk_window_set_title(GTK_WINDOW(win), "Results");
827 g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ui);
828 g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ui);
829
830 notebook = gtk_notebook_new();
831 gtk_container_add(GTK_CONTAINER(win), notebook);
832
833 ui->results_window = win;
834 ui->results_notebook = notebook;
835 return ui->results_notebook;
836}
837
3650a3ca
JA		 838static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
839 struct group_run_stats *rs)
840{
f9d40b48 841 GtkWidget *res_win, *box, *vbox, *entry;
e0681f3e 842 struct gfio_client *gc = client->client_data;
3650a3ca
JA		 843
844 gdk_threads_enter();
845
e0681f3e 846 res_win = get_results_window(gc->ui);
3650a3ca
JA		 847
848 vbox = gtk_vbox_new(FALSE, 3);
3650a3ca
JA		 849
850 box = gtk_hbox_new(TRUE, 3);
851 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
852
f9d40b48
JA		 853 gtk_notebook_append_page(GTK_NOTEBOOK(res_win), vbox, gtk_label_new(ts->name));
854
e0681f3e
JA		 855 gc->results_widget = vbox;
856
3650a3ca
JA		 857 entry = new_info_entry_in_frame(box, "Name");
858 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
859 if (strlen(ts->description)) {
860 entry = new_info_entry_in_frame(box, "Description");
861 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
862 }
863 entry = new_info_entry_in_frame(box, "Group ID");
864 entry_set_int_value(entry, ts->groupid);
865 entry = new_info_entry_in_frame(box, "Jobs");
866 entry_set_int_value(entry, ts->members);
867 entry = new_info_entry_in_frame(box, "Error");
868 entry_set_int_value(entry, ts->error);
869 entry = new_info_entry_in_frame(box, "PID");
870 entry_set_int_value(entry, ts->pid);
871
872 if (ts->io_bytes[DDIR_READ])
873 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
874 if (ts->io_bytes[DDIR_WRITE])
875 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
876
e5bd1347 877 gfio_show_latency_buckets(vbox, ts);
2e33101f
JA		 878 gfio_show_cpu_usage(vbox, ts);
879 gfio_show_io_depths(vbox, ts);
e5bd1347 880
e0681f3e 881 gtk_widget_show_all(gc->ui->results_window);
3650a3ca
JA		 882 gdk_threads_leave();
883}
884
084d1c6f 885static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
a1820207 886{
9b260bdf 887 struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
e0681f3e 888 struct gfio_client *gc = client->client_data;
9b260bdf
JA		 889 GtkTreeIter iter;
890 struct tm *tm;
891 time_t sec;
892 char tmp[64], timebuf[80];
893
894 sec = p->log_sec;
895 tm = localtime(&sec);
896 strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", tm);
897 sprintf(timebuf, "%s.%03ld", tmp, p->log_usec / 1000);
736f2dff 898
736f2dff 899 gdk_threads_enter();
9b260bdf 900
e0681f3e
JA		 901 gtk_list_store_append(gc->ui->log_model, &iter);
902 gtk_list_store_set(gc->ui->log_model, &iter, 0, timebuf, -1);
903 gtk_list_store_set(gc->ui->log_model, &iter, 1, client->hostname, -1);
904 gtk_list_store_set(gc->ui->log_model, &iter, 2, p->level, -1);
905 gtk_list_store_set(gc->ui->log_model, &iter, 3, p->buf, -1);
9b260bdf 906
736f2dff 907 gdk_threads_leave();
a1820207
SC		 908}
909
910static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
911{
e0681f3e
JA		 912 struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
913 struct gfio_client *gc = client->client_data;
914 GtkWidget *box, *frame, *entry, *vbox;
915
0050e5f2 916 gdk_threads_enter();
e0681f3e
JA		 917
918 if (!gc->results_widget) {
919 printf("no results!\n");
920 goto out;
921 }
922
923 if (!gc->disk_util_frame) {
924 gc->disk_util_frame = gtk_frame_new("Disk utilization");
925 gtk_box_pack_start(GTK_BOX(gc->results_widget), gc->disk_util_frame, FALSE, FALSE, 5);
926 }
927
928 vbox = gtk_vbox_new(FALSE, 3);
929 gtk_container_add(GTK_CONTAINER(gc->disk_util_frame), vbox);
930
931 frame = gtk_frame_new((char *) p->dus.name);
932 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 2);
933
934 box = gtk_vbox_new(FALSE, 3);
935 gtk_container_add(GTK_CONTAINER(frame), box);
936
937 frame = gtk_frame_new("Read");
938 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
939 vbox = gtk_hbox_new(TRUE, 3);
940 gtk_container_add(GTK_CONTAINER(frame), vbox);
941 entry = new_info_entry_in_frame(vbox, "IOs");
942 entry_set_int_value(entry, p->dus.ios[0]);
943 entry = new_info_entry_in_frame(vbox, "Merges");
944 entry_set_int_value(entry, p->dus.merges[0]);
945 entry = new_info_entry_in_frame(vbox, "Sectors");
946 entry_set_int_value(entry, p->dus.sectors[0]);
947 entry = new_info_entry_in_frame(vbox, "Ticks");
948 entry_set_int_value(entry, p->dus.ticks[0]);
949
950 frame = gtk_frame_new("Write");
951 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
952 vbox = gtk_hbox_new(TRUE, 3);
953 gtk_container_add(GTK_CONTAINER(frame), vbox);
954 entry = new_info_entry_in_frame(vbox, "IOs");
955 entry_set_int_value(entry, p->dus.ios[1]);
956 entry = new_info_entry_in_frame(vbox, "Merges");
957 entry_set_int_value(entry, p->dus.merges[1]);
958 entry = new_info_entry_in_frame(vbox, "Sectors");
959 entry_set_int_value(entry, p->dus.sectors[1]);
960 entry = new_info_entry_in_frame(vbox, "Ticks");
961 entry_set_int_value(entry, p->dus.ticks[1]);
962
963 frame = gtk_frame_new("Shared");
964 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 2);
965 vbox = gtk_hbox_new(TRUE, 3);
966 gtk_container_add(GTK_CONTAINER(frame), vbox);
967 entry = new_info_entry_in_frame(vbox, "IO ticks");
968 entry_set_int_value(entry, p->dus.io_ticks);
969 entry = new_info_entry_in_frame(vbox, "Time in queue");
970 entry_set_int_value(entry, p->dus.time_in_queue);
971
972 gtk_widget_show_all(gc->results_widget);
973out:
0050e5f2 974 gdk_threads_leave();
a1820207
SC		 975}
976
3650a3ca
JA		 977extern int sum_stat_clients;
978extern struct thread_stat client_ts;
979extern struct group_run_stats client_gs;
980
981static int sum_stat_nr;
982
89e5fad9
JA		 983static void gfio_thread_status_op(struct fio_client *client,
984 struct fio_net_cmd *cmd)
a1820207 985{
3650a3ca
JA		 986 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
987
988 gfio_display_ts(client, &p->ts, &p->rs);
989
990 if (sum_stat_clients == 1)
991 return;
992
993 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
994 sum_group_stats(&client_gs, &p->rs);
995
996 client_ts.members++;
997 client_ts.groupid = p->ts.groupid;
998
999 if (++sum_stat_nr == sum_stat_clients) {
1000 strcpy(client_ts.name, "All clients");
1001 gfio_display_ts(client, &client_ts, &client_gs);
1002 }
a1820207
SC		 1003}
1004
89e5fad9
JA		 1005static void gfio_group_stats_op(struct fio_client *client,
1006 struct fio_net_cmd *cmd)
a1820207 1007{
0050e5f2 1008 gdk_threads_enter();
a1820207 1009 printf("gfio_group_stats_op called\n");
89e5fad9 1010 fio_client_ops.group_stats(client, cmd);
0050e5f2 1011 gdk_threads_leave();
a1820207
SC		 1012}
1013
2fd3bb0e
JA		 1014static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
1015{
1016 struct gui *ui = (struct gui *) p;
1017 cairo_t *cr;
1018
1019 cr = gdk_cairo_create(w->window);
1020
1021 cairo_set_source_rgb(cr, 0, 0, 0);
1022
1023 cairo_save(cr);
1024 cairo_translate(cr, 0, 0);
1025 line_graph_draw(ui->bandwidth_graph, cr);
1026 cairo_stroke(cr);
1027 cairo_restore(cr);
1028
1029 cairo_save(cr);
1030 cairo_translate(cr, DRAWING_AREA_XDIM / 2.0, 0);
1031 // DRAWING_AREA_YDIM * 0.05);
1032 line_graph_draw(ui->iops_graph, cr);
1033 cairo_stroke(cr);
1034 cairo_restore(cr);
1035 cairo_destroy(cr);
1036
1037 return FALSE;
1038}
1039
3e47bd25
JA		 1040static void gfio_update_eta(struct jobs_eta *je)
1041{
1042 static int eta_good;
1043 char eta_str[128];
1044 char output[256];
1045 char tmp[32];
1046 double perc = 0.0;
1047 int i2p = 0;
1048
0050e5f2
JA		 1049 gdk_threads_enter();
1050
3e47bd25
JA		 1051 eta_str[0] = '\0';
1052 output[0] = '\0';
1053
1054 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
1055 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
1056 eta_to_str(eta_str, je->eta_sec);
1057 }
1058
1059 sprintf(tmp, "%u", je->nr_running);
ca850992 1060 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
3e47bd25 1061 sprintf(tmp, "%u", je->files_open);
ca850992 1062 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
3e47bd25
JA		 1063
1064#if 0
1065 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
1066 if (je->m_rate || je->t_rate) {
1067 char *tr, *mr;
1068
1069 mr = num2str(je->m_rate, 4, 0, i2p);
1070 tr = num2str(je->t_rate, 4, 0, i2p);
ca850992 1071 gtk_entry_set_text(GTK_ENTRY(ui.eta);
3e47bd25
JA		 1072 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
1073 free(tr);
1074 free(mr);
1075 } else if (je->m_iops || je->t_iops)
1076 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
ebbd89cc 1077
ca850992
JA		 1078 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
1079 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
1080 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
1081 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
3e47bd25
JA		 1082#endif
1083
1084 if (je->eta_sec != INT_MAX && je->nr_running) {
1085 char *iops_str[2];
1086 char *rate_str[2];
1087
1088 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
1089 strcpy(output, "-.-% done");
1090 else {
1091 eta_good = 1;
1092 perc *= 100.0;
1093 sprintf(output, "%3.1f%% done", perc);
1094 }
1095
1096 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
1097 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
1098
1099 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
1100 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
1101
ca850992
JA		 1102 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
1103 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
1104 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
1105 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
3e47bd25 1106
2fd3bb0e
JA		 1107 graph_add_xy_data(ui.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
1108 graph_add_xy_data(ui.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
1109 graph_add_xy_data(ui.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
1110 graph_add_xy_data(ui.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
1111
3e47bd25
JA		 1112 free(rate_str[0]);
1113 free(rate_str[1]);
1114 free(iops_str[0]);
1115 free(iops_str[1]);
1116 }
1117
1118 if (eta_str[0]) {
1119 char *dst = output + strlen(output);
1120
1121 sprintf(dst, " - %s", eta_str);
1122 }
1123
1124 gfio_update_thread_status(output, perc);
0050e5f2 1125 gdk_threads_leave();
3e47bd25
JA		 1126}
1127
a1820207
SC		 1128static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
1129{
843ad237 1130 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
88f6e7ad
JA		 1131 struct gfio_client *gc = client->client_data;
1132 struct gui *ui = gc->ui;
843ad237
JA		 1133 const char *os, *arch;
1134 char buf[64];
1135
1136 os = fio_get_os_string(probe->os);
1137 if (!os)
1138 os = "unknown";
1139
1140 arch = fio_get_arch_string(probe->arch);
1141 if (!arch)
1142 os = "unknown";
1143
1144 if (!client->name)
1145 client->name = strdup((char *) probe->hostname);
1146
0050e5f2
JA		 1147 gdk_threads_enter();
1148
88f6e7ad
JA		 1149 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), (char *) probe->hostname);
1150 gtk_label_set_text(GTK_LABEL(ui->probe.os), os);
1151 gtk_label_set_text(GTK_LABEL(ui->probe.arch), arch);
843ad237 1152 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
88f6e7ad
JA		 1153 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), buf);
1154
1155 gfio_set_connected(ui, 1);
0050e5f2
JA		 1156
1157 gdk_threads_leave();
a1820207
SC		 1158}
1159
04cc6b77 1160static void gfio_update_thread_status(char *status_message, double perc)
5b7573ab
SC		 1161{
1162 static char message[100];
1163 const char *m = message;
1164
1165 strncpy(message, status_message, sizeof(message) - 1);
04cc6b77
SC		 1166 gtk_progress_bar_set_text(
1167 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
1168 gtk_progress_bar_set_fraction(
1169 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
5b7573ab 1170 gtk_widget_queue_draw(ui.window);
5b7573ab
SC		 1171}
1172
3ec62ec4
JA		 1173static void gfio_quit_op(struct fio_client *client)
1174{
e0681f3e 1175 struct gfio_client *gc = client->client_data;
3ec62ec4 1176
0050e5f2 1177 gdk_threads_enter();
e0681f3e 1178 gfio_set_connected(gc->ui, 0);
0050e5f2 1179 gdk_threads_leave();
3ec62ec4
JA		 1180}
1181
807f9971
JA		 1182static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
1183{
1184 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
e0681f3e
JA		 1185 struct gfio_client *gc = client->client_data;
1186 struct gui *ui = gc->ui;
807f9971
JA		 1187 char tmp[8];
1188 int i;
1189
1190 p->iodepth = le32_to_cpu(p->iodepth);
1191 p->rw = le32_to_cpu(p->rw);
1192
1193 for (i = 0; i < 2; i++) {
1194 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
1195 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
1196 }
1197
1198 p->numjobs = le32_to_cpu(p->numjobs);
1199 p->group_reporting = le32_to_cpu(p->group_reporting);
1200
0050e5f2
JA		 1201 gdk_threads_enter();
1202
ca850992
JA		 1203 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
1204 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
1205 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
807f9971
JA		 1206
1207 sprintf(tmp, "%u", p->iodepth);
ca850992 1208 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
0050e5f2
JA		 1209
1210 gdk_threads_leave();
807f9971
JA		 1211}
1212
ed727a46
JA		 1213static void gfio_client_timed_out(struct fio_client *client)
1214{
e0681f3e 1215 struct gfio_client *gc = client->client_data;
ed727a46
JA		 1216 GtkWidget *dialog, *label, *content;
1217 char buf[256];
1218
1219 gdk_threads_enter();
1220
e0681f3e
JA		 1221 gfio_set_connected(gc->ui, 0);
1222 clear_ui_info(gc->ui);
ed727a46
JA		 1223
1224 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
1225
1226 dialog = gtk_dialog_new_with_buttons("Timed out!",
e0681f3e 1227 GTK_WINDOW(gc->ui->window),
ed727a46
JA		 1228 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
1229 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
1230
1231 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1232 label = gtk_label_new((const gchar *) buf);
1233 gtk_container_add(GTK_CONTAINER(content), label);
1234 gtk_widget_show_all(dialog);
1235 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
1236
1237 gtk_dialog_run(GTK_DIALOG(dialog));
1238 gtk_widget_destroy(dialog);
1239
1240 gdk_threads_leave();
1241}
1242
a1820207 1243struct client_ops gfio_client_ops = {
0420ba6a
JA		 1244 .text_op = gfio_text_op,
1245 .disk_util = gfio_disk_util_op,
1246 .thread_status = gfio_thread_status_op,
1247 .group_stats = gfio_group_stats_op,
a5276616 1248 .eta = gfio_update_eta,
0420ba6a 1249 .probe = gfio_probe_op,
3ec62ec4 1250 .quit = gfio_quit_op,
807f9971 1251 .add_job = gfio_add_job_op,
ed727a46 1252 .timed_out = gfio_client_timed_out,
3ec62ec4 1253 .stay_connected = 1,
a1820207
SC		 1254};
1255
ff1f3280
SC		 1256static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1257 __attribute__((unused)) gpointer data)
1258{
1259 gtk_main_quit();
1260}
1261
25927259
SC		 1262static void *job_thread(void *arg)
1263{
25927259 1264 fio_handle_clients(&gfio_client_ops);
25927259
SC		 1265 return NULL;
1266}
1267
0420ba6a 1268static int send_job_files(struct gui *ui)
60f6b330 1269{
441013b4 1270 int i, ret = 0;
0420ba6a
JA		 1271
1272 for (i = 0; i < ui->nr_job_files; i++) {
1273 ret = fio_clients_send_ini(ui->job_files[i]);
441013b4
JA		 1274 if (ret)
1275 break;
1276
0420ba6a
JA		 1277 free(ui->job_files[i]);
1278 ui->job_files[i] = NULL;
441013b4
JA		 1279 }
1280 while (i < ui->nr_job_files) {
1281 free(ui->job_files[i]);
1282 ui->job_files[i] = NULL;
1283 i++;
0420ba6a
JA		 1284 }
1285
441013b4 1286 return ret;
60f6b330
SC		 1287}
1288
3ec62ec4 1289static void start_job_thread(struct gui *ui)
25927259 1290{
0420ba6a 1291 if (send_job_files(ui)) {
60f6b330 1292 printf("Yeah, I didn't really like those options too much.\n");
60f6b330
SC		 1293 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
1294 return;
1295 }
25927259
SC		 1296}
1297
63a130b7
JA		 1298static void *server_thread(void *arg)
1299{
1300 is_backend = 1;
1301 gfio_server_running = 1;
1302 fio_start_server(NULL);
1303 gfio_server_running = 0;
1304 return NULL;
1305}
1306
1307static void gfio_start_server(struct gui *ui)
1308{
1309 if (!gfio_server_running) {
1310 gfio_server_running = 1;
1311 pthread_create(&ui->server_t, NULL, server_thread, NULL);
e34f6ad7 1312 pthread_detach(ui->server_t);
63a130b7
JA		 1313 }
1314}
1315
f3074008 1316static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
25927259 1317 gpointer data)
f3074008 1318{
25927259
SC		 1319 struct gui *ui = data;
1320
25927259 1321 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
3ec62ec4 1322 start_job_thread(ui);
f3074008
SC		 1323}
1324
df06f220
JA		 1325static void file_open(GtkWidget *w, gpointer data);
1326
1327static void connect_clicked(GtkWidget *widget, gpointer data)
3e47bd25 1328{
3ec62ec4
JA		 1329 struct gui *ui = data;
1330
1331 if (!ui->connected) {
df06f220
JA		 1332 if (!ui->nr_job_files)
1333 file_open(widget, data);
8663ea65 1334 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
e34f6ad7 1335 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
69406b92
JA		 1336 if (!fio_clients_connect()) {
1337 pthread_create(&ui->t, NULL, job_thread, NULL);
1338 gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 0);
1339 }
df06f220
JA		 1340 } else {
1341 fio_clients_terminate();
3ec62ec4 1342 gfio_set_connected(ui, 0);
88432651 1343 clear_ui_info(ui);
df06f220 1344 }
3e47bd25
JA		 1345}
1346
f3074008
SC		 1347static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
1348 struct button_spec *buttonspec)
1349{
1350 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
1351 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
3ec62ec4 1352 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
f3074008 1353 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
3e47bd25 1354 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
f3074008
SC		 1355}
1356
1357static void add_buttons(struct gui *ui,
1358 struct button_spec *buttonlist,
1359 int nbuttons)
1360{
1361 int i;
1362
f3074008
SC		 1363 for (i = 0; i < nbuttons; i++)
1364 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
1365}
1366
0420ba6a
JA		 1367static void on_info_bar_response(GtkWidget *widget, gint response,
1368 gpointer data)
1369{
1370 if (response == GTK_RESPONSE_OK) {
1371 gtk_widget_destroy(widget);
1372 ui.error_info_bar = NULL;
1373 }
1374}
1375
df06f220 1376void report_error(GError *error)
0420ba6a
JA		 1377{
1378 if (ui.error_info_bar == NULL) {
1379 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1380 GTK_RESPONSE_OK,
1381 NULL);
1382 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1383 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
1384 GTK_MESSAGE_ERROR);
1385
1386 ui.error_label = gtk_label_new(error->message);
1387 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
1388 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
1389
1390 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
1391 gtk_widget_show_all(ui.vbox);
1392 } else {
1393 char buffer[256];
1394 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1395 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
1396 }
1397}
1398
62bc937f
JA		 1399struct connection_widgets
1400{
1401 GtkWidget *hentry;
1402 GtkWidget *combo;
1403 GtkWidget *button;
1404};
1405
1406static void hostname_cb(GtkEntry *entry, gpointer data)
1407{
1408 struct connection_widgets *cw = data;
1409 int uses_net = 0, is_localhost = 0;
1410 const gchar *text;
1411 gchar *ctext;
1412
1413 /*
1414 * Check whether to display the 'auto start backend' box
1415 * or not. Show it if we are a localhost and using network,
1416 * or using a socket.
1417 */
1418 ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
1419 if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
1420 uses_net = 1;
1421 g_free(ctext);
1422
1423 if (uses_net) {
1424 text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
1425 if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
1426 !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
1427 !strcmp(text, "ip6-loopback"))
1428 is_localhost = 1;
1429 }
1430
1431 if (!uses_net || is_localhost) {
1432 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
1433 gtk_widget_set_sensitive(cw->button, 1);
1434 } else {
1435 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
1436 gtk_widget_set_sensitive(cw->button, 0);
1437 }
1438}
1439
b9f3c7ed
JA		 1440static int get_connection_details(char **host, int *port, int *type,
1441 int *server_start)
a7a42ce1 1442{
62bc937f
JA		 1443 GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
1444 struct connection_widgets cw;
a7a42ce1
JA		 1445 char *typeentry;
1446
1447 dialog = gtk_dialog_new_with_buttons("Connection details",
1448 GTK_WINDOW(ui.window),
1449 GTK_DIALOG_DESTROY_WITH_PARENT,
1450 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1451 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1452
1453 frame = gtk_frame_new("Hostname / socket name");
1454 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1455 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1456
1457 box = gtk_vbox_new(FALSE, 6);
1458 gtk_container_add(GTK_CONTAINER(frame), box);
1459
1460 hbox = gtk_hbox_new(TRUE, 10);
1461 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
62bc937f
JA		 1462 cw.hentry = gtk_entry_new();
1463 gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
1464 gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
a7a42ce1
JA		 1465
1466 frame = gtk_frame_new("Port");
1467 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1468 box = gtk_vbox_new(FALSE, 10);
1469 gtk_container_add(GTK_CONTAINER(frame), box);
1470
1471 hbox = gtk_hbox_new(TRUE, 4);
1472 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1473 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1474
1475 frame = gtk_frame_new("Type");
1476 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1477 box = gtk_vbox_new(FALSE, 10);
1478 gtk_container_add(GTK_CONTAINER(frame), box);
1479
1480 hbox = gtk_hbox_new(TRUE, 4);
1481 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1482
62bc937f
JA		 1483 cw.combo = gtk_combo_box_new_text();
1484 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
1485 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
1486 gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
1487 gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
a7a42ce1 1488
62bc937f 1489 gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
a7a42ce1 1490
b9f3c7ed
JA		 1491 frame = gtk_frame_new("Options");
1492 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1493 box = gtk_vbox_new(FALSE, 10);
1494 gtk_container_add(GTK_CONTAINER(frame), box);
1495
1496 hbox = gtk_hbox_new(TRUE, 4);
1497 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1498
62bc937f
JA		 1499 cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1500 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
1501 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.");
1502 gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
1503
1504 /*
1505 * Connect edit signal, so we can show/not-show the auto start button
1506 */
1507 g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
1508 g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
b9f3c7ed 1509
a7a42ce1
JA		 1510 gtk_widget_show_all(dialog);
1511
1512 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1513 gtk_widget_destroy(dialog);
1514 return 1;
1515 }
1516
62bc937f 1517 *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
a7a42ce1
JA		 1518 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1519
62bc937f 1520 typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
a7a42ce1
JA		 1521 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1522 *type = Fio_client_ipv4;
1523 else if (!strncmp(typeentry, "IPv6", 4))
1524 *type = Fio_client_ipv6;
1525 else
1526 *type = Fio_client_socket;
1527 g_free(typeentry);
1528
62bc937f 1529 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
b9f3c7ed 1530
a7a42ce1
JA		 1531 gtk_widget_destroy(dialog);
1532 return 0;
1533}
1534
e0681f3e
JA		 1535static void gfio_client_added(struct gui *ui, struct fio_client *client)
1536{
1537 struct gfio_client *gc;
1538
1539 gc = malloc(sizeof(*gc));
1540 memset(gc, 0, sizeof(*gc));
1541 gc->ui = ui;
1542
1543 client->client_data = gc;
1544}
1545
0420ba6a
JA		 1546static void file_open(GtkWidget *w, gpointer data)
1547{
1548 GtkWidget *dialog;
63a130b7 1549 struct gui *ui = data;
0420ba6a
JA		 1550 GSList *filenames, *fn_glist;
1551 GtkFileFilter *filter;
a7a42ce1 1552 char *host;
b9f3c7ed 1553 int port, type, server_start;
0420ba6a
JA		 1554
1555 dialog = gtk_file_chooser_dialog_new("Open File",
63a130b7 1556 GTK_WINDOW(ui->window),
0420ba6a
JA		 1557 GTK_FILE_CHOOSER_ACTION_OPEN,
1558 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1559 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1560 NULL);
1561 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1562
1563 filter = gtk_file_filter_new();
1564 gtk_file_filter_add_pattern(filter, "*.fio");
1565 gtk_file_filter_add_pattern(filter, "*.job");
2d262990 1566 gtk_file_filter_add_pattern(filter, "*.ini");
0420ba6a
JA		 1567 gtk_file_filter_add_mime_type(filter, "text/fio");
1568 gtk_file_filter_set_name(filter, "Fio job file");
1569 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1570
1571 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1572 gtk_widget_destroy(dialog);
1573 return;
1574 }
1575
1576 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
a7a42ce1
JA		 1577
1578 gtk_widget_destroy(dialog);
1579
b9f3c7ed 1580 if (get_connection_details(&host, &port, &type, &server_start))
a7a42ce1
JA		 1581 goto err;
1582
0420ba6a
JA		 1583 filenames = fn_glist;
1584 while (filenames != NULL) {
e0681f3e
JA		 1585 struct fio_client *client;
1586
63a130b7
JA		 1587 ui->job_files = realloc(ui->job_files, (ui->nr_job_files + 1) * sizeof(char *));
1588 ui->job_files[ui->nr_job_files] = strdup(filenames->data);
1589 ui->nr_job_files++;
0420ba6a 1590
e0681f3e
JA		 1591 client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
1592 if (!client) {
df06f220
JA		 1593 GError *error;
1594
1595 error = g_error_new(g_quark_from_string("fio"), 1,
1596 "Failed to add client %s", host);
0420ba6a
JA		 1597 report_error(error);
1598 g_error_free(error);
0420ba6a 1599 }
63a130b7 1600 gfio_client_added(ui, client);
0420ba6a
JA		 1601
1602 g_free(filenames->data);
1603 filenames = g_slist_next(filenames);
1604 }
a7a42ce1 1605 free(host);
63a130b7
JA		 1606
1607 if (server_start)
1608 gfio_start_server(ui);
a7a42ce1 1609err:
0420ba6a 1610 g_slist_free(fn_glist);
0420ba6a
JA		 1611}
1612
1613static void file_save(GtkWidget *w, gpointer data)
1614{
63a130b7 1615 struct gui *ui = data;
0420ba6a
JA		 1616 GtkWidget *dialog;
1617
1618 dialog = gtk_file_chooser_dialog_new("Save File",
63a130b7 1619 GTK_WINDOW(ui->window),
0420ba6a
JA		 1620 GTK_FILE_CHOOSER_ACTION_SAVE,
1621 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1622 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1623 NULL);
1624
1625 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1626 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1627
1628 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1629 char *filename;
1630
1631 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1632 // save_job_file(filename);
1633 g_free(filename);
1634 }
1635 gtk_widget_destroy(dialog);
1636}
1637
9b260bdf
JA		 1638static void view_log_destroy(GtkWidget *w, gpointer data)
1639{
1640 struct gui *ui = (struct gui *) data;
1641
1642 gtk_widget_ref(ui->log_tree);
1643 gtk_container_remove(GTK_CONTAINER(w), ui->log_tree);
1644 gtk_widget_destroy(w);
4cbe7211 1645 ui->log_view = NULL;
9b260bdf
JA		 1646}
1647
1648static void view_log(GtkWidget *w, gpointer data)
1649{
4cbe7211
JA		 1650 GtkWidget *win, *scroll, *vbox, *box;
1651 struct gui *ui = (struct gui *) data;
9b260bdf 1652
4cbe7211
JA		 1653 if (ui->log_view)
1654 return;
1655
1656 ui->log_view = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
9b260bdf 1657 gtk_window_set_title(GTK_WINDOW(win), "Log");
4cbe7211 1658 gtk_window_set_default_size(GTK_WINDOW(win), 700, 500);
9b260bdf 1659
4cbe7211
JA		 1660 scroll = gtk_scrolled_window_new(NULL, NULL);
1661
1662 gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
1663
1664 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1665
1666 box = gtk_hbox_new(TRUE, 0);
1667 gtk_box_pack_start_defaults(GTK_BOX(box), ui->log_tree);
1668 g_signal_connect(box, "destroy", G_CALLBACK(view_log_destroy), ui);
1669 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), box);
1670
1671 vbox = gtk_vbox_new(TRUE, 5);
1672 gtk_box_pack_start_defaults(GTK_BOX(vbox), scroll);
9b260bdf 1673
4cbe7211 1674 gtk_container_add(GTK_CONTAINER(win), vbox);
9b260bdf
JA		 1675 gtk_widget_show_all(win);
1676}
1677
46974a7d
JA		 1678static void preferences(GtkWidget *w, gpointer data)
1679{
f3e8440f 1680 GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
46974a7d
JA		 1681 int i;
1682
1683 dialog = gtk_dialog_new_with_buttons("Preferences",
1684 GTK_WINDOW(ui.window),
1685 GTK_DIALOG_DESTROY_WITH_PARENT,
1686 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1687 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1688 NULL);
1689
0b8d11ed 1690 frame = gtk_frame_new("Debug logging");
46974a7d 1691 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
f3e8440f
JA		 1692
1693 vbox = gtk_vbox_new(FALSE, 6);
1694 gtk_container_add(GTK_CONTAINER(frame), vbox);
1695
46974a7d 1696 box = gtk_hbox_new(FALSE, 6);
f3e8440f 1697 gtk_container_add(GTK_CONTAINER(vbox), box);
46974a7d
JA		 1698
1699 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1700
1701 for (i = 0; i < FD_DEBUG_MAX; i++) {
f3e8440f
JA		 1702 if (i == 7) {
1703 box = gtk_hbox_new(FALSE, 6);
1704 gtk_container_add(GTK_CONTAINER(vbox), box);
1705 }
1706
1707
46974a7d 1708 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
0b8d11ed 1709 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
46974a7d
JA		 1710 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1711 }
1712
f3e8440f
JA		 1713 frame = gtk_frame_new("Graph font");
1714 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1715 vbox = gtk_vbox_new(FALSE, 6);
1716 gtk_container_add(GTK_CONTAINER(frame), vbox);
1717
1718 font = gtk_font_button_new();
1719 gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5);
1720
46974a7d
JA		 1721 gtk_widget_show_all(dialog);
1722
1723 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1724 gtk_widget_destroy(dialog);
1725 return;
1726 }
1727
1728 for (i = 0; i < FD_DEBUG_MAX; i++) {
1729 int set;
1730
1731 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1732 if (set)
1733 fio_debug |= (1UL << i);
1734 }
1735
f3e8440f
JA		 1736 gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
1737 printf("got font %s\n", gfio_graph_font);
1738
46974a7d
JA		 1739 gtk_widget_destroy(dialog);
1740}
1741
0420ba6a
JA		 1742static void about_dialog(GtkWidget *w, gpointer data)
1743{
81e4ea6e
JA		 1744 const char *authors[] = {
1745 "Jens Axboe <axboe@kernel.dk>",
1746 "Stephen Carmeron <stephenmcameron@gmail.com>",
1747 NULL
1748 };
84a72ed3
JA		 1749 const char *license[] = {
1750 "Fio is free software; you can redistribute it and/or modify "
1751 "it under the terms of the GNU General Public License as published by "
1752 "the Free Software Foundation; either version 2 of the License, or "
1753 "(at your option) any later version.\n",
1754 "Fio is distributed in the hope that it will be useful, "
1755 "but WITHOUT ANY WARRANTY; without even the implied warranty of "
1756 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
1757 "GNU General Public License for more details.\n",
1758 "You should have received a copy of the GNU General Public License "
1759 "along with Fio; if not, write to the Free Software Foundation, Inc., "
1760 "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
1761 };
1762 char *license_trans;
1763
1764 license_trans = g_strconcat(license[0], "\n", license[1], "\n",
1765 license[2], "\n", NULL);
81e4ea6e 1766
0420ba6a
JA		 1767 gtk_show_about_dialog(NULL,
1768 "program-name", "gfio",
1769 "comments", "Gtk2 UI for fio",
84a72ed3 1770 "license", license_trans,
81e4ea6e
JA		 1771 "website", "http://git.kernel.dk/?p=fio.git;a=summary",
1772 "authors", authors,
0420ba6a 1773 "version", fio_version_string,
81e4ea6e 1774 "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
0420ba6a
JA		 1775 "logo-icon-name", "fio",
1776 /* Must be last: */
81e4ea6e 1777 "wrap-license", TRUE,
0420ba6a 1778 NULL);
84a72ed3
JA		 1779
1780 g_free (license_trans);
0420ba6a
JA		 1781}
1782
1783static GtkActionEntry menu_items[] = {
46974a7d 1784 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
9b260bdf 1785 { "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
46974a7d
JA		 1786 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1787 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1788 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1789 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
9b260bdf 1790 { "ViewLog", NULL, "Log", "<Control>l", NULL, G_CALLBACK(view_log) },
46974a7d
JA		 1791 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1792 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
0420ba6a 1793};
3e47bd25 1794static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
0420ba6a
JA		 1795
1796static const gchar *ui_string = " \
1797 <ui> \
1798 <menubar name=\"MainMenu\"> \
1799 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1800 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1801 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1802 <separator name=\"Separator\"/> \
46974a7d
JA		 1803 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1804 <separator name=\"Separator2\"/> \
0420ba6a
JA		 1805 <menuitem name=\"Quit\" action=\"Quit\" /> \
1806 </menu> \
9b260bdf
JA		 1807 <menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
1808 <menuitem name=\"Log\" action=\"ViewLog\" /> \
1809 </menu>\
0420ba6a
JA		 1810 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1811 <menuitem name=\"About\" action=\"About\" /> \
1812 </menu> \
1813 </menubar> \
1814 </ui> \
1815";
1816
4cbe7211
JA		 1817static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager,
1818 struct gui *ui)
0420ba6a
JA		 1819{
1820 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1821 GError *error = 0;
1822
1823 action_group = gtk_action_group_new("Menu");
4cbe7211 1824 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, ui);
0420ba6a
JA		 1825
1826 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1827 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1828
1829 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1830 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1831}
1832
1833void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1834 GtkWidget *vbox, GtkUIManager *ui_manager)
1835{
1836 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1837}
1838
ff1f3280
SC		 1839static void init_ui(int *argc, char **argv[], struct gui *ui)
1840{
0420ba6a
JA		 1841 GtkSettings *settings;
1842 GtkUIManager *uimanager;
843ad237 1843 GtkWidget *menu, *probe, *probe_frame, *probe_box;
aaa71f68 1844 GdkColor white;
0420ba6a
JA		 1845
1846 memset(ui, 0, sizeof(*ui));
45032dd8 1847
2839f0c6 1848 /* Magical g*thread incantation, you just need this thread stuff.
04cc6b77 1849 * Without it, the update that happens in gfio_update_thread_status
2839f0c6
SC		 1850 * doesn't really happen in a timely fashion, you need expose events
1851 */
ed727a46 1852 if (!g_thread_supported())
2839f0c6
SC		 1853 g_thread_init(NULL);
1854 gdk_threads_init();
1855
ff1f3280 1856 gtk_init(argc, argv);
0420ba6a
JA		 1857 settings = gtk_settings_get_default();
1858 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1859 g_type_init();
ff1f3280
SC		 1860
1861 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1862 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
f3e8440f 1863 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 700);
ff1f3280 1864
0420ba6a
JA		 1865 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1866 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
ff1f3280 1867
5b7573ab
SC		 1868 ui->vbox = gtk_vbox_new(FALSE, 0);
1869 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
04cc6b77 1870
0420ba6a 1871 uimanager = gtk_ui_manager_new();
4cbe7211 1872 menu = get_menubar_menu(ui->window, uimanager, ui);
0420ba6a
JA		 1873 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1874
c36f98d9
SC		 1875 /*
1876 * Set up alignments for widgets at the top of ui,
1877 * align top left, expand horizontally but not vertically
1878 */
1879 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
3ec62ec4 1880 ui->topvbox = gtk_vbox_new(FALSE, 3);
c36f98d9 1881 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
e164534f 1882 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
c36f98d9 1883
3e47bd25 1884 probe = gtk_frame_new("Job");
843ad237
JA		 1885 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1886 probe_frame = gtk_vbox_new(FALSE, 3);
1887 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1888
1889 probe_box = gtk_hbox_new(FALSE, 3);
1890 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
843ad237
JA		 1891 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1892 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1893 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1894 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1895
3e47bd25
JA		 1896 probe_box = gtk_hbox_new(FALSE, 3);
1897 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971 1898
ca850992
JA		 1899 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1900 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1901 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1902 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1903 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1904 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
3e47bd25
JA		 1905
1906 probe_box = gtk_hbox_new(FALSE, 3);
1907 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
ca850992
JA		 1908 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1909 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1910 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1911 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
3e47bd25 1912
807f9971
JA		 1913 /*
1914 * Only add this if we have a commit rate
1915 */
1916#if 0
3e47bd25
JA		 1917 probe_box = gtk_hbox_new(FALSE, 3);
1918 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971
JA		 1919
1920 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1921 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1922
3e47bd25
JA		 1923 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1924 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
807f9971 1925#endif
3e47bd25 1926
736f2dff 1927 /*
2fd3bb0e 1928 * Set up a drawing area and IOPS and bandwidth graphs
736f2dff 1929 */
aaa71f68 1930 gdk_color_parse("white", &white);
2fd3bb0e
JA		 1931 ui->drawing_area = gtk_drawing_area_new();
1932 gtk_widget_set_size_request(GTK_WIDGET(ui->drawing_area),
1933 DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
aaa71f68 1934 gtk_widget_modify_bg(ui->drawing_area, GTK_STATE_NORMAL, &white);
2fd3bb0e
JA		 1935 g_signal_connect(G_OBJECT(ui->drawing_area), "expose_event",
1936 G_CALLBACK (on_expose_drawing_area), ui);
736f2dff
SC		 1937 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1938 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1939 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
2fd3bb0e
JA		 1940 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1941 ui->drawing_area);
e164534f
SC		 1942 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1943 TRUE, TRUE, 0);
736f2dff 1944
2fd3bb0e
JA		 1945 setup_iops_graph(ui);
1946 setup_bandwidth_graph(ui);
1947
c36f98d9
SC		 1948 /*
1949 * Set up alignments for widgets at the bottom of ui,
1950 * align bottom left, expand horizontally but not vertically
1951 */
1952 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1953 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1954 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
e164534f
SC		 1955 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1956 FALSE, FALSE, 0);
c36f98d9 1957
f3074008 1958 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
3ec62ec4
JA		 1959
1960 /*
1961 * Set up thread status progress bar
1962 */
1963 ui->thread_status_pb = gtk_progress_bar_new();
1964 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
8663ea65 1965 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
3ec62ec4
JA		 1966 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1967
9b260bdf 1968 gfio_ui_setup_log(ui);
3ec62ec4 1969
ff1f3280
SC		 1970 gtk_widget_show_all(ui->window);
1971}
1972
8232e285 1973int main(int argc, char *argv[], char *envp[])
ff1f3280 1974{
8232e285
SC		 1975 if (initialize_fio(envp))
1976 return 1;
0420ba6a
JA		 1977 if (fio_init_options())
1978 return 1;
a1820207 1979
ff1f3280 1980 init_ui(&argc, &argv, &ui);
5b7573ab 1981
2839f0c6 1982 gdk_threads_enter();
ff1f3280 1983 gtk_main();
2839f0c6 1984 gdk_threads_leave();
ff1f3280
SC		 1985 return 0;
1986}
fio - Flexible IO Tester