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