projects / fio.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gfio: move bandwidth stats
[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>
5 *
6 * The license below covers all files distributed with fio unless otherwise
7 * noted in the file itself.
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 *
22 */
8232e285 23#include <locale.h>
60f6b330 24#include <malloc.h>
8232e285 25
5b7573ab 26#include <glib.h>
ff1f3280
SC		 27#include <gtk/gtk.h>
28
8232e285
SC		 29#include "fio.h"
30
3e47bd25
JA		 31static void gfio_update_thread_status(char *status_message, double perc);
32
f3074008
SC		 33#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
34
35typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
36
3e47bd25 37static void connect_clicked(GtkWidget *widget, gpointer data);
f3074008
SC		 38static void start_job_clicked(GtkWidget *widget, gpointer data);
39
40static struct button_spec {
41 const char *buttontext;
42 clickfunction f;
43 const char *tooltiptext;
3e47bd25 44 const int start_insensitive;
f3074008 45} buttonspeclist[] = {
3e47bd25
JA		 46#define CONNECT_BUTTON 0
47#define START_JOB_BUTTON 1
48 { "Connect", connect_clicked, "Connect to host", 0 },
f3074008
SC		 49 { "Start Job",
50 start_job_clicked,
3e47bd25 51 "Send current fio job to fio server to be executed", 1 },
f3074008
SC		 52};
53
843ad237
JA		 54struct probe_widget {
55 GtkWidget *hostname;
56 GtkWidget *os;
57 GtkWidget *arch;
58 GtkWidget *fio_ver;
59};
60
3e47bd25 61struct eta_widget {
807f9971
JA		 62 GtkWidget *name;
63 GtkWidget *iotype;
64 GtkWidget *ioengine;
65 GtkWidget *iodepth;
3e47bd25
JA		 66 GtkWidget *jobs;
67 GtkWidget *files;
68 GtkWidget *read_bw;
69 GtkWidget *read_iops;
70 GtkWidget *cr_bw;
71 GtkWidget *cr_iops;
72 GtkWidget *write_bw;
73 GtkWidget *write_iops;
74 GtkWidget *cw_bw;
75 GtkWidget *cw_iops;
76};
77
ff1f3280
SC		 78struct gui {
79 GtkWidget *window;
5b7573ab 80 GtkWidget *vbox;
c36f98d9
SC		 81 GtkWidget *topvbox;
82 GtkWidget *topalign;
83 GtkWidget *bottomalign;
04cc6b77 84 GtkWidget *thread_status_pb;
f3074008
SC		 85 GtkWidget *buttonbox;
86 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
736f2dff
SC		 87 GtkWidget *scrolled_window;
88 GtkWidget *textview;
0420ba6a
JA		 89 GtkWidget *error_info_bar;
90 GtkWidget *error_label;
736f2dff 91 GtkTextBuffer *text;
843ad237 92 struct probe_widget probe;
3e47bd25 93 struct eta_widget eta;
3ec62ec4 94 int connected;
25927259 95 pthread_t t;
0420ba6a 96
3ec62ec4 97 struct fio_client *client;
0420ba6a
JA		 98 int nr_job_files;
99 char **job_files;
5b7573ab 100} ui;
ff1f3280 101
8663ea65
JA		 102static void clear_ui_info(struct gui *ui)
103{
104 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
105 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
106 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
107 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
ca850992
JA		 108 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
109 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
110 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
111 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
112 gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
113 gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
114 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
115 gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
116 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
117 gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
8663ea65
JA		 118}
119
3650a3ca
JA		 120static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
121{
122 GtkWidget *entry, *frame;
123
124 frame = gtk_frame_new(label);
125 entry = gtk_entry_new();
1c1e4a5b 126 gtk_entry_set_editable(GTK_ENTRY(entry), 0);
3650a3ca
JA		 127 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
128 gtk_container_add(GTK_CONTAINER(frame), entry);
129
130 return entry;
131}
132
133static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
134{
135 GtkWidget *label_widget;
136 GtkWidget *frame;
137
138 frame = gtk_frame_new(label);
139 label_widget = gtk_label_new(NULL);
140 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
141 gtk_container_add(GTK_CONTAINER(frame), label_widget);
142
143 return label_widget;
144}
145
146static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
147{
148 GtkWidget *button, *box;
149
150 box = gtk_hbox_new(FALSE, 3);
151 gtk_container_add(GTK_CONTAINER(hbox), box);
152
153 button = gtk_spin_button_new_with_range(min, max, 1.0);
154 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
155
156 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
157 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
158
159 return button;
160}
161
3ec62ec4
JA		 162static void gfio_set_connected(struct gui *ui, int connected)
163{
164 if (connected) {
165 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
166 ui->connected = 1;
167 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
168 } else {
169 ui->connected = 0;
170 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
171 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
172 }
173}
174
3650a3ca
JA		 175static void label_set_int_value(GtkWidget *entry, unsigned int val)
176{
177 char tmp[80];
178
179 sprintf(tmp, "%u", val);
180 gtk_label_set_text(GTK_LABEL(entry), tmp);
181}
182
183static void entry_set_int_value(GtkWidget *entry, unsigned int val)
184{
185 char tmp[80];
186
187 sprintf(tmp, "%u", val);
188 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
189}
190
a269790c
JA		 191#define ALIGN_LEFT 1
192#define ALIGN_RIGHT 2
193#define INVISIBLE 4
194#define UNSORTABLE 8
195
196GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
197{
198 GtkCellRenderer *renderer;
199 GtkTreeViewColumn *col;
200 double xalign = 0.0; /* left as default */
201 PangoAlignment align;
202 gboolean visible;
203
204 align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
205 (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
206 PANGO_ALIGN_CENTER;
207 visible = !(flags & INVISIBLE);
208
209 renderer = gtk_cell_renderer_text_new();
210 col = gtk_tree_view_column_new();
211
212 gtk_tree_view_column_set_title(col, title);
213 if (!(flags & UNSORTABLE))
214 gtk_tree_view_column_set_sort_column_id(col, index);
215 gtk_tree_view_column_set_resizable(col, TRUE);
216 gtk_tree_view_column_pack_start(col, renderer, TRUE);
217 gtk_tree_view_column_add_attribute(col, renderer, "text", index);
218 gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
219 switch (align) {
220 case PANGO_ALIGN_LEFT:
221 xalign = 0.0;
222 break;
223 case PANGO_ALIGN_CENTER:
224 xalign = 0.5;
225 break;
226 case PANGO_ALIGN_RIGHT:
227 xalign = 1.0;
228 break;
229 }
230 gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
231 gtk_tree_view_column_set_visible(col, visible);
232 gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
233 return col;
234}
235
236static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
237 fio_fp64_t *plist,
238 unsigned int len,
239 const char *base,
240 unsigned int scale)
241{
242 GType types[FIO_IO_U_LIST_MAX_LEN];
243 GtkWidget *tree_view;
244 GtkTreeSelection *selection;
245 GtkListStore *model;
246 GtkTreeIter iter;
247 int i;
248
249 for (i = 0; i < len; i++)
250 types[i] = G_TYPE_INT;
251
252 model = gtk_list_store_newv(len, types);
253
254 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
255 gtk_widget_set_can_focus(tree_view, FALSE);
256
257 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
258 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
259
260 for (i = 0; i < len; i++) {
261 char fbuf[8];
262
263 sprintf(fbuf, "%2.2f%%", plist[i].u.f);
264 tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
265 }
266
267 gtk_list_store_append(model, &iter);
268
269 for (i = 0; i < len; i++)
270 gtk_list_store_set(model, &iter, i, ovals[i], -1);
271
272 return tree_view;
273}
274
275static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
276 int ddir)
277{
278 unsigned int *io_u_plat = ts->io_u_plat[ddir];
279 unsigned long nr = ts->clat_stat[ddir].samples;
280 fio_fp64_t *plist = ts->percentile_list;
281 unsigned int *ovals, len, minv, maxv, scale_down;
282 const char *base;
283 GtkWidget *tree_view, *frame, *hbox;
284 char tmp[64];
285
286 len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
287 if (!len)
288 goto out;
289
290 /*
291 * We default to usecs, but if the value range is such that we
292 * should scale down to msecs, do that.
293 */
294 if (minv > 2000 && maxv > 99999) {
295 scale_down = 1;
296 base = "msec";
297 } else {
298 scale_down = 0;
299 base = "usec";
300 }
301
302 tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
303
304 sprintf(tmp, "Completion percentiles (%s)", base);
305 frame = gtk_frame_new(tmp);
306 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
307
308 hbox = gtk_hbox_new(FALSE, 3);
309 gtk_container_add(GTK_CONTAINER(frame), hbox);
310
311 gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
312out:
313 if (ovals)
314 free(ovals);
315}
316
3650a3ca
JA		 317static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
318 unsigned long max, double mean, double dev)
319{
320 const char *base = "(usec)";
1c1e4a5b 321 GtkWidget *hbox, *label, *frame;
3650a3ca
JA		 322 char *minp, *maxp;
323 char tmp[64];
324
325 if (!usec_to_msec(&min, &max, &mean, &dev))
326 base = "(msec)";
327
328 minp = num2str(min, 6, 1, 0);
329 maxp = num2str(max, 6, 1, 0);
330
3650a3ca
JA		 331 sprintf(tmp, "%s %s", name, base);
332 frame = gtk_frame_new(tmp);
333 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
334
3650a3ca 335 hbox = gtk_hbox_new(FALSE, 3);
1c1e4a5b 336 gtk_container_add(GTK_CONTAINER(frame), hbox);
3650a3ca
JA		 337
338 label = new_info_label_in_frame(hbox, "Minimum");
339 gtk_label_set_text(GTK_LABEL(label), minp);
340 label = new_info_label_in_frame(hbox, "Maximum");
341 gtk_label_set_text(GTK_LABEL(label), maxp);
342 label = new_info_label_in_frame(hbox, "Average");
343 sprintf(tmp, "%5.02f", mean);
344 gtk_label_set_text(GTK_LABEL(label), tmp);
345 label = new_info_label_in_frame(hbox, "Standard deviation");
346 sprintf(tmp, "%5.02f", dev);
347 gtk_label_set_text(GTK_LABEL(label), tmp);
348
349 free(minp);
350 free(maxp);
351
352}
353
ca850992
JA		 354#define GFIO_CLAT 1
355#define GFIO_SLAT 2
356#define GFIO_LAT 4
357
3650a3ca
JA		 358static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
359 struct thread_stat *ts, int ddir)
360{
361 const char *ddir_label[2] = { "Read", "Write" };
0b761306 362 GtkWidget *frame, *label, *box, *vbox, *main_vbox;
3650a3ca
JA		 363 unsigned long min, max, runt;
364 unsigned long long bw, iops;
ca850992 365 unsigned int flags = 0;
3650a3ca
JA		 366 double mean, dev;
367 char *io_p, *bw_p, *iops_p;
368 int i2p;
369
370 if (!ts->runtime[ddir])
371 return;
372
373 i2p = is_power_of_2(rs->kb_base);
374 runt = ts->runtime[ddir];
375
376 bw = (1000 * ts->io_bytes[ddir]) / runt;
377 io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
378 bw_p = num2str(bw, 6, 1, i2p);
379
380 iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
381 iops_p = num2str(iops, 6, 1, 0);
382
383 box = gtk_hbox_new(FALSE, 3);
384 gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
385
386 frame = gtk_frame_new(ddir_label[ddir]);
387 gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
388
0b761306
JA		 389 main_vbox = gtk_vbox_new(FALSE, 3);
390 gtk_container_add(GTK_CONTAINER(frame), main_vbox);
3650a3ca
JA		 391
392 box = gtk_hbox_new(FALSE, 3);
0b761306 393 gtk_box_pack_start(GTK_BOX(main_vbox), box, TRUE, FALSE, 3);
3650a3ca
JA		 394
395 label = new_info_label_in_frame(box, "IO");
396 gtk_label_set_text(GTK_LABEL(label), io_p);
397 label = new_info_label_in_frame(box, "Bandwidth");
398 gtk_label_set_text(GTK_LABEL(label), bw_p);
399 label = new_info_label_in_frame(box, "IOPS");
400 gtk_label_set_text(GTK_LABEL(label), iops_p);
401 label = new_info_label_in_frame(box, "Runtime (msec)");
402 label_set_int_value(label, ts->runtime[ddir]);
403
ca850992
JA		 404 if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) {
405 double p_of_agg = 100.0;
406 const char *bw_str = "KB";
407 char tmp[32];
408
409 if (rs->agg[ddir]) {
410 p_of_agg = mean * 100 / (double) rs->agg[ddir];
411 if (p_of_agg > 100.0)
412 p_of_agg = 100.0;
413 }
414
415 if (mean > 999999.9) {
416 min /= 1000.0;
417 max /= 1000.0;
418 mean /= 1000.0;
419 dev /= 1000.0;
420 bw_str = "MB";
421 }
422
0b761306
JA		 423 sprintf(tmp, "Bandwidth (%s)", bw_str);
424 frame = gtk_frame_new(tmp);
425 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
ca850992 426
0b761306
JA		 427 box = gtk_hbox_new(FALSE, 3);
428 gtk_container_add(GTK_CONTAINER(frame), box);
ca850992 429
0b761306 430 label = new_info_label_in_frame(box, "Minimum");
ca850992 431 label_set_int_value(label, min);
0b761306 432 label = new_info_label_in_frame(box, "Maximum");
ca850992 433 label_set_int_value(label, max);
0b761306 434 label = new_info_label_in_frame(box, "Percentage of jobs");
ca850992
JA		 435 sprintf(tmp, "%3.2f%%", p_of_agg);
436 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 437 label = new_info_label_in_frame(box, "Average");
ca850992
JA		 438 sprintf(tmp, "%5.02f", mean);
439 gtk_label_set_text(GTK_LABEL(label), tmp);
0b761306 440 label = new_info_label_in_frame(box, "Standard deviation");
ca850992
JA		 441 sprintf(tmp, "%5.02f", dev);
442 gtk_label_set_text(GTK_LABEL(label), tmp);
443 }
444
2b089892
JA		 445 if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev))
446 flags |= GFIO_SLAT;
447 if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev))
448 flags |= GFIO_CLAT;
449 if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev))
450 flags |= GFIO_LAT;
451
452 if (flags) {
453 frame = gtk_frame_new("Latency");
454 gtk_box_pack_start(GTK_BOX(main_vbox), frame, FALSE, FALSE, 5);
455
456 vbox = gtk_vbox_new(FALSE, 3);
457 gtk_container_add(GTK_CONTAINER(frame), vbox);
458
459 if (flags & GFIO_SLAT)
460 gfio_show_lat(vbox, "Submission latency", min, max, mean, dev);
461 if (flags & GFIO_CLAT)
462 gfio_show_lat(vbox, "Completion latency", min, max, mean, dev);
463 if (flags & GFIO_LAT)
464 gfio_show_lat(vbox, "Total latency", min, max, mean, dev);
465 }
466
467 if (ts->clat_percentiles)
468 gfio_show_clat_percentiles(main_vbox, ts, ddir);
469
470
3650a3ca
JA		 471 free(io_p);
472 free(bw_p);
473 free(iops_p);
474}
475
e5bd1347
JA		 476static GtkWidget *gfio_output_lat_buckets(double *lat, unsigned int num,
477 const char **labels)
478{
479 GtkWidget *tree_view;
480 GtkTreeSelection *selection;
481 GtkListStore *model;
482 GtkTreeIter iter;
483 GType *types;
484 int i, skipped;
485
486 /*
487 * Check if all are empty, in which case don't bother
488 */
489 for (i = 0, skipped = 0; i < num; i++)
490 if (lat[i] <= 0.0)
491 skipped++;
492
493 if (skipped == num)
494 return NULL;
495
496 types = malloc(num * sizeof(GType));
497
498 for (i = 0; i < num; i++)
499 types[i] = G_TYPE_STRING;
500
501 model = gtk_list_store_newv(num, types);
502 free(types);
503 types = NULL;
504
505 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
506 gtk_widget_set_can_focus(tree_view, FALSE);
507
508 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
509 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
510
511 for (i = 0; i < num; i++)
512 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
513
514 gtk_list_store_append(model, &iter);
515
516 for (i = 0; i < num; i++) {
517 char fbuf[32];
518
519 if (lat[i] <= 0.0)
520 sprintf(fbuf, "0.00");
521 else
522 sprintf(fbuf, "%3.2f%%", lat[i]);
523
524 gtk_list_store_set(model, &iter, i, fbuf, -1);
525 }
526
527 return tree_view;
528}
529
530static void gfio_show_latency_buckets(GtkWidget *vbox, struct thread_stat *ts)
531{
532 GtkWidget *box, *frame, *tree_view;
533 double io_u_lat_u[FIO_IO_U_LAT_U_NR];
534 double io_u_lat_m[FIO_IO_U_LAT_M_NR];
535 const char *uranges[] = { "2", "4", "10", "20", "50", "100",
536 "250", "500", "750", "1000", };
537 const char *mranges[] = { "2", "4", "10", "20", "50", "100",
538 "250", "500", "750", "1000", "2000",
539 ">= 2000", };
540
541 stat_calc_lat_u(ts, io_u_lat_u);
542 stat_calc_lat_m(ts, io_u_lat_m);
543
544 tree_view = gfio_output_lat_buckets(io_u_lat_u, FIO_IO_U_LAT_U_NR, uranges);
545 if (tree_view) {
546 frame = gtk_frame_new("Latency buckets (usec)");
547 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
548
549 box = gtk_hbox_new(FALSE, 3);
550 gtk_container_add(GTK_CONTAINER(frame), box);
551 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
552 }
553
554 tree_view = gfio_output_lat_buckets(io_u_lat_m, FIO_IO_U_LAT_M_NR, mranges);
555 if (tree_view) {
556 frame = gtk_frame_new("Latency buckets (msec)");
557 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
558
559 box = gtk_hbox_new(FALSE, 3);
560 gtk_container_add(GTK_CONTAINER(frame), box);
561 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
562 }
563}
564
2e33101f
JA		 565static void gfio_show_cpu_usage(GtkWidget *vbox, struct thread_stat *ts)
566{
567 GtkWidget *box, *frame, *entry;
568 double usr_cpu, sys_cpu;
569 unsigned long runtime;
570 char tmp[32];
571
572 runtime = ts->total_run_time;
573 if (runtime) {
574 double runt = (double) runtime;
575
576 usr_cpu = (double) ts->usr_time * 100 / runt;
577 sys_cpu = (double) ts->sys_time * 100 / runt;
578 } else {
579 usr_cpu = 0;
580 sys_cpu = 0;
581 }
582
583 frame = gtk_frame_new("OS resources");
584 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
585
586 box = gtk_hbox_new(FALSE, 3);
587 gtk_container_add(GTK_CONTAINER(frame), box);
588
589 entry = new_info_entry_in_frame(box, "User CPU");
590 sprintf(tmp, "%3.2f%%", usr_cpu);
591 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
592 entry = new_info_entry_in_frame(box, "System CPU");
593 sprintf(tmp, "%3.2f%%", sys_cpu);
594 gtk_entry_set_text(GTK_ENTRY(entry), tmp);
595 entry = new_info_entry_in_frame(box, "Context switches");
596 entry_set_int_value(entry, ts->ctx);
597 entry = new_info_entry_in_frame(box, "Major faults");
598 entry_set_int_value(entry, ts->majf);
599 entry = new_info_entry_in_frame(box, "Minor faults");
600 entry_set_int_value(entry, ts->minf);
601}
602
603static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
604{
605 double io_u_dist[FIO_IO_U_MAP_NR];
606 double io_u_dist_s[FIO_IO_U_MAP_NR];
607 double io_u_dist_c[FIO_IO_U_MAP_NR];
608 GtkWidget *frame, *box, *tree_view;
609 GtkTreeSelection *selection;
610 GtkListStore *model;
611 GtkTreeIter iter;
612 GType types[FIO_IO_U_MAP_NR + 1];
613 int i;
614 const char *labels[] = { "Type", "0", "4", "8", "16", "32", "64", ">= 64" };
615
616 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
617 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist_s);
618 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist_c);
619
620 frame = gtk_frame_new("IO depths");
621 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
622
623 box = gtk_hbox_new(FALSE, 3);
624 gtk_container_add(GTK_CONTAINER(frame), box);
625
626 for (i = 0; i < FIO_IO_U_MAP_NR + 1; i++)
627 types[i] = G_TYPE_STRING;
628
629 model = gtk_list_store_newv(FIO_IO_U_MAP_NR + 1, types);
630
631 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
632 gtk_widget_set_can_focus(tree_view, FALSE);
633
634 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
635 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
636
637 for (i = 0; i < FIO_IO_U_MAP_NR + 1; i++)
638 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
639
640 gtk_list_store_append(model, &iter);
641
642 for (i = 0; i < FIO_IO_U_MAP_NR + 1; i++) {
643 char fbuf[32];
644
645 if (i == 0) {
646 gtk_list_store_set(model, &iter, i, "Total", -1);
647 continue;
648 }
649
650 sprintf(fbuf, "%3.1f%%", io_u_dist[i - 1]);
651 gtk_list_store_set(model, &iter, i, fbuf, -1);
652 }
653
654 gtk_list_store_append(model, &iter);
655
656 for (i = 0; i < FIO_IO_U_MAP_NR + 1; i++) {
657 char fbuf[32];
658
659 if (i == 0) {
660 gtk_list_store_set(model, &iter, i, "Submit", -1);
661 continue;
662 }
663
664 sprintf(fbuf, "%3.1f%%", io_u_dist_s[i - 1]);
665 gtk_list_store_set(model, &iter, i, fbuf, -1);
666 }
667
668 gtk_list_store_append(model, &iter);
669
670 for (i = 0; i < FIO_IO_U_MAP_NR + 1; i++) {
671 char fbuf[32];
672
673 if (i == 0) {
674 gtk_list_store_set(model, &iter, i, "Complete", -1);
675 continue;
676 }
677
678 sprintf(fbuf, "%3.1f%%", io_u_dist_c[i - 1]);
679 gtk_list_store_set(model, &iter, i, fbuf, -1);
680 }
681
682 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
683}
684
3650a3ca
JA		 685static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
686 struct group_run_stats *rs)
687{
688 GtkWidget *dialog, *box, *vbox, *entry, *content;
689 struct gui *ui = client->client_data;
690
691 gdk_threads_enter();
692
693 dialog = gtk_dialog_new_with_buttons("Results", GTK_WINDOW(ui->window),
694 GTK_DIALOG_DESTROY_WITH_PARENT,
695 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
696
697 g_signal_connect_swapped(dialog, "response",
698 G_CALLBACK(gtk_widget_destroy),
699 dialog);
700
701 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
702
703 vbox = gtk_vbox_new(FALSE, 3);
704 gtk_container_add(GTK_CONTAINER(content), vbox);
705
706 box = gtk_hbox_new(TRUE, 3);
707 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
708
709 entry = new_info_entry_in_frame(box, "Name");
710 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
711 if (strlen(ts->description)) {
712 entry = new_info_entry_in_frame(box, "Description");
713 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
714 }
715 entry = new_info_entry_in_frame(box, "Group ID");
716 entry_set_int_value(entry, ts->groupid);
717 entry = new_info_entry_in_frame(box, "Jobs");
718 entry_set_int_value(entry, ts->members);
719 entry = new_info_entry_in_frame(box, "Error");
720 entry_set_int_value(entry, ts->error);
721 entry = new_info_entry_in_frame(box, "PID");
722 entry_set_int_value(entry, ts->pid);
723
724 if (ts->io_bytes[DDIR_READ])
725 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
726 if (ts->io_bytes[DDIR_WRITE])
727 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
728
e5bd1347 729 gfio_show_latency_buckets(vbox, ts);
2e33101f
JA		 730 gfio_show_cpu_usage(vbox, ts);
731 gfio_show_io_depths(vbox, ts);
e5bd1347 732
3650a3ca 733 gtk_widget_show_all(dialog);
3650a3ca
JA		 734 gdk_threads_leave();
735}
736
084d1c6f 737static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
a1820207 738{
807f9971 739#if 0
736f2dff
SC		 740 GtkTextBuffer *buffer;
741 GtkTextIter end;
742
743 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui.textview));
744 gdk_threads_enter();
745 gtk_text_buffer_get_end_iter(buffer, &end);
746 gtk_text_buffer_insert(buffer, &end, buf, -1);
747 gdk_threads_leave();
748 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ui.textview),
749 &end, 0.0, FALSE, 0.0,0.0);
807f9971 750#else
084d1c6f 751 fio_client_ops.text_op(client, cmd);
807f9971 752#endif
a1820207
SC		 753}
754
755static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
756{
757 printf("gfio_disk_util_op called\n");
758 fio_client_ops.disk_util(client, cmd);
759}
760
3650a3ca
JA		 761extern int sum_stat_clients;
762extern struct thread_stat client_ts;
763extern struct group_run_stats client_gs;
764
765static int sum_stat_nr;
766
89e5fad9
JA		 767static void gfio_thread_status_op(struct fio_client *client,
768 struct fio_net_cmd *cmd)
a1820207 769{
3650a3ca
JA		 770 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
771
772 gfio_display_ts(client, &p->ts, &p->rs);
773
774 if (sum_stat_clients == 1)
775 return;
776
777 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
778 sum_group_stats(&client_gs, &p->rs);
779
780 client_ts.members++;
781 client_ts.groupid = p->ts.groupid;
782
783 if (++sum_stat_nr == sum_stat_clients) {
784 strcpy(client_ts.name, "All clients");
785 gfio_display_ts(client, &client_ts, &client_gs);
786 }
a1820207
SC		 787}
788
89e5fad9
JA		 789static void gfio_group_stats_op(struct fio_client *client,
790 struct fio_net_cmd *cmd)
a1820207
SC		 791{
792 printf("gfio_group_stats_op called\n");
89e5fad9 793 fio_client_ops.group_stats(client, cmd);
a1820207
SC		 794}
795
3e47bd25
JA		 796static void gfio_update_eta(struct jobs_eta *je)
797{
798 static int eta_good;
799 char eta_str[128];
800 char output[256];
801 char tmp[32];
802 double perc = 0.0;
803 int i2p = 0;
804
805 eta_str[0] = '\0';
806 output[0] = '\0';
807
808 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
809 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
810 eta_to_str(eta_str, je->eta_sec);
811 }
812
813 sprintf(tmp, "%u", je->nr_running);
ca850992 814 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
3e47bd25 815 sprintf(tmp, "%u", je->files_open);
ca850992 816 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
3e47bd25
JA		 817
818#if 0
819 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
820 if (je->m_rate || je->t_rate) {
821 char *tr, *mr;
822
823 mr = num2str(je->m_rate, 4, 0, i2p);
824 tr = num2str(je->t_rate, 4, 0, i2p);
ca850992 825 gtk_entry_set_text(GTK_ENTRY(ui.eta);
3e47bd25
JA		 826 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
827 free(tr);
828 free(mr);
829 } else if (je->m_iops || je->t_iops)
830 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
ebbd89cc 831
ca850992
JA		 832 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
833 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
834 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
835 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
3e47bd25
JA		 836#endif
837
838 if (je->eta_sec != INT_MAX && je->nr_running) {
839 char *iops_str[2];
840 char *rate_str[2];
841
842 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
843 strcpy(output, "-.-% done");
844 else {
845 eta_good = 1;
846 perc *= 100.0;
847 sprintf(output, "%3.1f%% done", perc);
848 }
849
850 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
851 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
852
853 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
854 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
855
ca850992
JA		 856 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
857 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
858 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
859 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
3e47bd25
JA		 860
861 free(rate_str[0]);
862 free(rate_str[1]);
863 free(iops_str[0]);
864 free(iops_str[1]);
865 }
866
867 if (eta_str[0]) {
868 char *dst = output + strlen(output);
869
870 sprintf(dst, " - %s", eta_str);
871 }
872
873 gfio_update_thread_status(output, perc);
874}
875
a1820207
SC		 876static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
877{
843ad237
JA		 878 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
879 const char *os, *arch;
880 char buf[64];
881
882 os = fio_get_os_string(probe->os);
883 if (!os)
884 os = "unknown";
885
886 arch = fio_get_arch_string(probe->arch);
887 if (!arch)
888 os = "unknown";
889
890 if (!client->name)
891 client->name = strdup((char *) probe->hostname);
892
893 gtk_label_set_text(GTK_LABEL(ui.probe.hostname), (char *) probe->hostname);
894 gtk_label_set_text(GTK_LABEL(ui.probe.os), os);
895 gtk_label_set_text(GTK_LABEL(ui.probe.arch), arch);
896 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
897 gtk_label_set_text(GTK_LABEL(ui.probe.fio_ver), buf);
a1820207
SC		 898}
899
04cc6b77 900static void gfio_update_thread_status(char *status_message, double perc)
5b7573ab
SC		 901{
902 static char message[100];
903 const char *m = message;
904
905 strncpy(message, status_message, sizeof(message) - 1);
04cc6b77
SC		 906 gtk_progress_bar_set_text(
907 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
908 gtk_progress_bar_set_fraction(
909 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
5b7573ab
SC		 910 gdk_threads_enter();
911 gtk_widget_queue_draw(ui.window);
912 gdk_threads_leave();
913}
914
3ec62ec4
JA		 915static void gfio_quit_op(struct fio_client *client)
916{
917 struct gui *ui = client->client_data;
918
919 gfio_set_connected(ui, 0);
920}
921
807f9971
JA		 922static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
923{
924 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
925 struct gui *ui = client->client_data;
926 char tmp[8];
927 int i;
928
929 p->iodepth = le32_to_cpu(p->iodepth);
930 p->rw = le32_to_cpu(p->rw);
931
932 for (i = 0; i < 2; i++) {
933 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
934 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
935 }
936
937 p->numjobs = le32_to_cpu(p->numjobs);
938 p->group_reporting = le32_to_cpu(p->group_reporting);
939
ca850992
JA		 940 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
941 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
942 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
807f9971
JA		 943
944 sprintf(tmp, "%u", p->iodepth);
ca850992 945 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
807f9971
JA		 946}
947
ed727a46
JA		 948static void gfio_client_timed_out(struct fio_client *client)
949{
950 struct gui *ui = client->client_data;
951 GtkWidget *dialog, *label, *content;
952 char buf[256];
953
954 gdk_threads_enter();
955
956 gfio_set_connected(ui, 0);
88432651 957 clear_ui_info(ui);
ed727a46
JA		 958
959 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
960
961 dialog = gtk_dialog_new_with_buttons("Timed out!",
962 GTK_WINDOW(ui->window),
963 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
964 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
965
966 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
967 label = gtk_label_new((const gchar *) buf);
968 gtk_container_add(GTK_CONTAINER(content), label);
969 gtk_widget_show_all(dialog);
970 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
971
972 gtk_dialog_run(GTK_DIALOG(dialog));
973 gtk_widget_destroy(dialog);
974
975 gdk_threads_leave();
976}
977
a1820207 978struct client_ops gfio_client_ops = {
0420ba6a
JA		 979 .text_op = gfio_text_op,
980 .disk_util = gfio_disk_util_op,
981 .thread_status = gfio_thread_status_op,
982 .group_stats = gfio_group_stats_op,
a5276616 983 .eta = gfio_update_eta,
0420ba6a 984 .probe = gfio_probe_op,
3ec62ec4 985 .quit = gfio_quit_op,
807f9971 986 .add_job = gfio_add_job_op,
ed727a46 987 .timed_out = gfio_client_timed_out,
3ec62ec4 988 .stay_connected = 1,
a1820207
SC		 989};
990
ff1f3280
SC		 991static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
992 __attribute__((unused)) gpointer data)
993{
994 gtk_main_quit();
995}
996
25927259
SC		 997static void *job_thread(void *arg)
998{
25927259 999 fio_handle_clients(&gfio_client_ops);
25927259
SC		 1000 return NULL;
1001}
1002
0420ba6a 1003static int send_job_files(struct gui *ui)
60f6b330 1004{
441013b4 1005 int i, ret = 0;
0420ba6a
JA		 1006
1007 for (i = 0; i < ui->nr_job_files; i++) {
1008 ret = fio_clients_send_ini(ui->job_files[i]);
441013b4
JA		 1009 if (ret)
1010 break;
1011
0420ba6a
JA		 1012 free(ui->job_files[i]);
1013 ui->job_files[i] = NULL;
441013b4
JA		 1014 }
1015 while (i < ui->nr_job_files) {
1016 free(ui->job_files[i]);
1017 ui->job_files[i] = NULL;
1018 i++;
0420ba6a
JA		 1019 }
1020
441013b4 1021 return ret;
60f6b330
SC		 1022}
1023
3ec62ec4 1024static void start_job_thread(struct gui *ui)
25927259 1025{
0420ba6a 1026 if (send_job_files(ui)) {
60f6b330 1027 printf("Yeah, I didn't really like those options too much.\n");
60f6b330
SC		 1028 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
1029 return;
1030 }
25927259
SC		 1031}
1032
f3074008 1033static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
25927259 1034 gpointer data)
f3074008 1035{
25927259
SC		 1036 struct gui *ui = data;
1037
25927259 1038 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
3ec62ec4 1039 start_job_thread(ui);
f3074008
SC		 1040}
1041
df06f220
JA		 1042static void file_open(GtkWidget *w, gpointer data);
1043
1044static void connect_clicked(GtkWidget *widget, gpointer data)
3e47bd25 1045{
3ec62ec4
JA		 1046 struct gui *ui = data;
1047
1048 if (!ui->connected) {
df06f220
JA		 1049 if (!ui->nr_job_files)
1050 file_open(widget, data);
8663ea65 1051 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
3ec62ec4
JA		 1052 fio_clients_connect();
1053 pthread_create(&ui->t, NULL, job_thread, NULL);
1054 gfio_set_connected(ui, 1);
df06f220
JA		 1055 } else {
1056 fio_clients_terminate();
3ec62ec4 1057 gfio_set_connected(ui, 0);
88432651 1058 clear_ui_info(ui);
df06f220 1059 }
3e47bd25
JA		 1060}
1061
f3074008
SC		 1062static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
1063 struct button_spec *buttonspec)
1064{
1065 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
1066 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
3ec62ec4 1067 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
f3074008 1068 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
3e47bd25 1069 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
f3074008
SC		 1070}
1071
1072static void add_buttons(struct gui *ui,
1073 struct button_spec *buttonlist,
1074 int nbuttons)
1075{
1076 int i;
1077
f3074008
SC		 1078 for (i = 0; i < nbuttons; i++)
1079 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
1080}
1081
0420ba6a
JA		 1082static void on_info_bar_response(GtkWidget *widget, gint response,
1083 gpointer data)
1084{
1085 if (response == GTK_RESPONSE_OK) {
1086 gtk_widget_destroy(widget);
1087 ui.error_info_bar = NULL;
1088 }
1089}
1090
df06f220 1091void report_error(GError *error)
0420ba6a
JA		 1092{
1093 if (ui.error_info_bar == NULL) {
1094 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1095 GTK_RESPONSE_OK,
1096 NULL);
1097 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1098 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
1099 GTK_MESSAGE_ERROR);
1100
1101 ui.error_label = gtk_label_new(error->message);
1102 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
1103 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
1104
1105 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
1106 gtk_widget_show_all(ui.vbox);
1107 } else {
1108 char buffer[256];
1109 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1110 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
1111 }
1112}
1113
b9f3c7ed
JA		 1114static int get_connection_details(char **host, int *port, int *type,
1115 int *server_start)
a7a42ce1
JA		 1116{
1117 GtkWidget *dialog, *box, *vbox, *hentry, *hbox, *frame, *pentry, *combo;
b9f3c7ed 1118 GtkWidget *button;
a7a42ce1
JA		 1119 char *typeentry;
1120
1121 dialog = gtk_dialog_new_with_buttons("Connection details",
1122 GTK_WINDOW(ui.window),
1123 GTK_DIALOG_DESTROY_WITH_PARENT,
1124 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1125 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1126
1127 frame = gtk_frame_new("Hostname / socket name");
1128 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1129 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1130
1131 box = gtk_vbox_new(FALSE, 6);
1132 gtk_container_add(GTK_CONTAINER(frame), box);
1133
1134 hbox = gtk_hbox_new(TRUE, 10);
1135 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1136 hentry = gtk_entry_new();
1137 gtk_entry_set_text(GTK_ENTRY(hentry), "localhost");
1138 gtk_box_pack_start(GTK_BOX(hbox), hentry, TRUE, TRUE, 0);
1139
1140 frame = gtk_frame_new("Port");
1141 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1142 box = gtk_vbox_new(FALSE, 10);
1143 gtk_container_add(GTK_CONTAINER(frame), box);
1144
1145 hbox = gtk_hbox_new(TRUE, 4);
1146 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1147 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1148
1149 frame = gtk_frame_new("Type");
1150 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1151 box = gtk_vbox_new(FALSE, 10);
1152 gtk_container_add(GTK_CONTAINER(frame), box);
1153
1154 hbox = gtk_hbox_new(TRUE, 4);
1155 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1156
1157 combo = gtk_combo_box_text_new();
1158 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv4");
1159 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv6");
1160 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "local socket");
1161 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
1162
1163 gtk_container_add(GTK_CONTAINER(hbox), combo);
1164
b9f3c7ed
JA		 1165 frame = gtk_frame_new("Options");
1166 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1167 box = gtk_vbox_new(FALSE, 10);
1168 gtk_container_add(GTK_CONTAINER(frame), box);
1169
1170 hbox = gtk_hbox_new(TRUE, 4);
1171 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1172
1173 button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1174 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
1175 gtk_widget_set_tooltip_text(button, "When running fio locally, it is necessary to have the backend running on the same system. If this is checked, gfio will start the backend automatically for you if it isn't already running.");
1176 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 6);
1177
a7a42ce1
JA		 1178 gtk_widget_show_all(dialog);
1179
1180 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1181 gtk_widget_destroy(dialog);
1182 return 1;
1183 }
1184
1185 *host = strdup(gtk_entry_get_text(GTK_ENTRY(hentry)));
1186 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1187
1188 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
1189 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1190 *type = Fio_client_ipv4;
1191 else if (!strncmp(typeentry, "IPv6", 4))
1192 *type = Fio_client_ipv6;
1193 else
1194 *type = Fio_client_socket;
1195 g_free(typeentry);
1196
b9f3c7ed
JA		 1197 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
1198
a7a42ce1
JA		 1199 gtk_widget_destroy(dialog);
1200 return 0;
1201}
1202
0420ba6a
JA		 1203static void file_open(GtkWidget *w, gpointer data)
1204{
1205 GtkWidget *dialog;
1206 GSList *filenames, *fn_glist;
1207 GtkFileFilter *filter;
a7a42ce1 1208 char *host;
b9f3c7ed 1209 int port, type, server_start;
0420ba6a
JA		 1210
1211 dialog = gtk_file_chooser_dialog_new("Open File",
1212 GTK_WINDOW(ui.window),
1213 GTK_FILE_CHOOSER_ACTION_OPEN,
1214 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1215 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1216 NULL);
1217 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1218
1219 filter = gtk_file_filter_new();
1220 gtk_file_filter_add_pattern(filter, "*.fio");
1221 gtk_file_filter_add_pattern(filter, "*.job");
1222 gtk_file_filter_add_mime_type(filter, "text/fio");
1223 gtk_file_filter_set_name(filter, "Fio job file");
1224 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1225
1226 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1227 gtk_widget_destroy(dialog);
1228 return;
1229 }
1230
1231 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
a7a42ce1
JA		 1232
1233 gtk_widget_destroy(dialog);
1234
b9f3c7ed 1235 if (get_connection_details(&host, &port, &type, &server_start))
a7a42ce1
JA		 1236 goto err;
1237
0420ba6a
JA		 1238 filenames = fn_glist;
1239 while (filenames != NULL) {
0420ba6a
JA		 1240 ui.job_files = realloc(ui.job_files, (ui.nr_job_files + 1) * sizeof(char *));
1241 ui.job_files[ui.nr_job_files] = strdup(filenames->data);
1242 ui.nr_job_files++;
1243
a5276616 1244 ui.client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
df06f220
JA		 1245 if (!ui.client) {
1246 GError *error;
1247
1248 error = g_error_new(g_quark_from_string("fio"), 1,
1249 "Failed to add client %s", host);
0420ba6a
JA		 1250 report_error(error);
1251 g_error_free(error);
0420ba6a 1252 }
df06f220 1253 ui.client->client_data = &ui;
0420ba6a
JA		 1254
1255 g_free(filenames->data);
1256 filenames = g_slist_next(filenames);
1257 }
a7a42ce1
JA		 1258 free(host);
1259err:
0420ba6a 1260 g_slist_free(fn_glist);
0420ba6a
JA		 1261}
1262
1263static void file_save(GtkWidget *w, gpointer data)
1264{
1265 GtkWidget *dialog;
1266
1267 dialog = gtk_file_chooser_dialog_new("Save File",
1268 GTK_WINDOW(ui.window),
1269 GTK_FILE_CHOOSER_ACTION_SAVE,
1270 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1271 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1272 NULL);
1273
1274 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1275 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1276
1277 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1278 char *filename;
1279
1280 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1281 // save_job_file(filename);
1282 g_free(filename);
1283 }
1284 gtk_widget_destroy(dialog);
1285}
1286
46974a7d
JA		 1287static void preferences(GtkWidget *w, gpointer data)
1288{
1289 GtkWidget *dialog, *frame, *box, **buttons;
1290 int i;
1291
1292 dialog = gtk_dialog_new_with_buttons("Preferences",
1293 GTK_WINDOW(ui.window),
1294 GTK_DIALOG_DESTROY_WITH_PARENT,
1295 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1296 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1297 NULL);
1298
0b8d11ed 1299 frame = gtk_frame_new("Debug logging");
46974a7d
JA		 1300 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1301 box = gtk_hbox_new(FALSE, 6);
1302 gtk_container_add(GTK_CONTAINER(frame), box);
1303
1304 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1305
1306 for (i = 0; i < FD_DEBUG_MAX; i++) {
1307 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
0b8d11ed 1308 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
46974a7d
JA		 1309 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1310 }
1311
1312 gtk_widget_show_all(dialog);
1313
1314 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1315 gtk_widget_destroy(dialog);
1316 return;
1317 }
1318
1319 for (i = 0; i < FD_DEBUG_MAX; i++) {
1320 int set;
1321
1322 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1323 if (set)
1324 fio_debug |= (1UL << i);
1325 }
1326
1327 gtk_widget_destroy(dialog);
1328}
1329
0420ba6a
JA		 1330static void about_dialog(GtkWidget *w, gpointer data)
1331{
1332 gtk_show_about_dialog(NULL,
1333 "program-name", "gfio",
1334 "comments", "Gtk2 UI for fio",
1335 "license", "GPLv2",
1336 "version", fio_version_string,
1337 "copyright", "Jens Axboe <axboe@kernel.dk> 2012",
1338 "logo-icon-name", "fio",
1339 /* Must be last: */
1340 NULL, NULL,
1341 NULL);
1342}
1343
1344static GtkActionEntry menu_items[] = {
46974a7d
JA		 1345 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1346 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1347 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1348 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1349 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1350 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1351 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
0420ba6a 1352};
3e47bd25 1353static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
0420ba6a
JA		 1354
1355static const gchar *ui_string = " \
1356 <ui> \
1357 <menubar name=\"MainMenu\"> \
1358 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1359 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1360 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1361 <separator name=\"Separator\"/> \
46974a7d
JA		 1362 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1363 <separator name=\"Separator2\"/> \
0420ba6a
JA		 1364 <menuitem name=\"Quit\" action=\"Quit\" /> \
1365 </menu> \
1366 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1367 <menuitem name=\"About\" action=\"About\" /> \
1368 </menu> \
1369 </menubar> \
1370 </ui> \
1371";
1372
1373static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager)
1374{
1375 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1376 GError *error = 0;
1377
1378 action_group = gtk_action_group_new("Menu");
1379 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
1380
1381 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1382 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1383
1384 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1385 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1386}
1387
1388void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1389 GtkWidget *vbox, GtkUIManager *ui_manager)
1390{
1391 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1392}
1393
ff1f3280
SC		 1394static void init_ui(int *argc, char **argv[], struct gui *ui)
1395{
0420ba6a
JA		 1396 GtkSettings *settings;
1397 GtkUIManager *uimanager;
843ad237 1398 GtkWidget *menu, *probe, *probe_frame, *probe_box;
0420ba6a
JA		 1399
1400 memset(ui, 0, sizeof(*ui));
45032dd8 1401
2839f0c6 1402 /* Magical g*thread incantation, you just need this thread stuff.
04cc6b77 1403 * Without it, the update that happens in gfio_update_thread_status
2839f0c6
SC		 1404 * doesn't really happen in a timely fashion, you need expose events
1405 */
ed727a46 1406 if (!g_thread_supported())
2839f0c6
SC		 1407 g_thread_init(NULL);
1408 gdk_threads_init();
1409
ff1f3280 1410 gtk_init(argc, argv);
0420ba6a
JA		 1411 settings = gtk_settings_get_default();
1412 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1413 g_type_init();
ff1f3280
SC		 1414
1415 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1416 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1417 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 500);
1418
0420ba6a
JA		 1419 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1420 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
ff1f3280 1421
5b7573ab
SC		 1422 ui->vbox = gtk_vbox_new(FALSE, 0);
1423 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
04cc6b77 1424
0420ba6a
JA		 1425 uimanager = gtk_ui_manager_new();
1426 menu = get_menubar_menu(ui->window, uimanager);
1427 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1428
c36f98d9
SC		 1429 /*
1430 * Set up alignments for widgets at the top of ui,
1431 * align top left, expand horizontally but not vertically
1432 */
1433 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
3ec62ec4 1434 ui->topvbox = gtk_vbox_new(FALSE, 3);
c36f98d9 1435 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
e164534f 1436 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
c36f98d9 1437
3e47bd25 1438 probe = gtk_frame_new("Job");
843ad237
JA		 1439 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1440 probe_frame = gtk_vbox_new(FALSE, 3);
1441 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1442
1443 probe_box = gtk_hbox_new(FALSE, 3);
1444 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
843ad237
JA		 1445 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1446 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1447 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1448 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1449
3e47bd25
JA		 1450 probe_box = gtk_hbox_new(FALSE, 3);
1451 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971 1452
ca850992
JA		 1453 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1454 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1455 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1456 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1457 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1458 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
3e47bd25
JA		 1459
1460 probe_box = gtk_hbox_new(FALSE, 3);
1461 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
ca850992
JA		 1462 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1463 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1464 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1465 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
3e47bd25 1466
807f9971
JA		 1467 /*
1468 * Only add this if we have a commit rate
1469 */
1470#if 0
3e47bd25
JA		 1471 probe_box = gtk_hbox_new(FALSE, 3);
1472 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971
JA		 1473
1474 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1475 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1476
3e47bd25
JA		 1477 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1478 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
807f9971 1479#endif
3e47bd25 1480
736f2dff
SC		 1481 /*
1482 * Add a text box for text op messages
1483 */
1484 ui->textview = gtk_text_view_new();
1485 ui->text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui->textview));
1486 gtk_text_buffer_set_text(ui->text, "", -1);
1487 gtk_text_view_set_editable(GTK_TEXT_VIEW(ui->textview), FALSE);
1488 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ui->textview), FALSE);
1489 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1490 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1491 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1492 gtk_container_add(GTK_CONTAINER(ui->scrolled_window), ui->textview);
e164534f
SC		 1493 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1494 TRUE, TRUE, 0);
736f2dff 1495
c36f98d9
SC		 1496 /*
1497 * Set up alignments for widgets at the bottom of ui,
1498 * align bottom left, expand horizontally but not vertically
1499 */
1500 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1501 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1502 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
e164534f
SC		 1503 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1504 FALSE, FALSE, 0);
c36f98d9 1505
f3074008 1506 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
3ec62ec4
JA		 1507
1508 /*
1509 * Set up thread status progress bar
1510 */
1511 ui->thread_status_pb = gtk_progress_bar_new();
1512 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
8663ea65 1513 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
3ec62ec4
JA		 1514 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1515
1516
ff1f3280
SC		 1517 gtk_widget_show_all(ui->window);
1518}
1519
8232e285 1520int main(int argc, char *argv[], char *envp[])
ff1f3280 1521{
8232e285
SC		 1522 if (initialize_fio(envp))
1523 return 1;
0420ba6a
JA		 1524 if (fio_init_options())
1525 return 1;
a1820207 1526
ff1f3280 1527 init_ui(&argc, &argv, &ui);
5b7573ab 1528
2839f0c6 1529 gdk_threads_enter();
ff1f3280 1530 gtk_main();
2839f0c6 1531 gdk_threads_leave();
ff1f3280
SC		 1532 return 0;
1533}
fio - Flexible IO Tester