projects / fio.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
gfio: correct depths view
[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}
19998dbc
JA		 602static void gfio_add_sc_depths_tree(GtkListStore *model,
603 struct thread_stat *ts, unsigned int len,
604 int submit)
2e33101f
JA		 605{
606 double io_u_dist[FIO_IO_U_MAP_NR];
2e33101f 607 GtkTreeIter iter;
19998dbc
JA		 608 /* Bits 0, and 3-8 */
609 const int add_mask = 0x1f9;
610 int i, j;
2e33101f 611
19998dbc
JA		 612 if (submit)
613 stat_calc_dist(ts->io_u_submit, ts->total_submit, io_u_dist);
614 else
615 stat_calc_dist(ts->io_u_complete, ts->total_complete, io_u_dist);
2e33101f 616
19998dbc 617 gtk_list_store_append(model, &iter);
2e33101f 618
19998dbc 619 gtk_list_store_set(model, &iter, 0, submit ? "Submit" : "Complete", -1);
2e33101f 620
19998dbc
JA		 621 for (i = 1, j = 0; i < len; i++) {
622 char fbuf[32];
2e33101f 623
19998dbc
JA		 624 if (!(add_mask & (1UL << (i - 1))))
625 sprintf(fbuf, "0.0%%");
626 else {
627 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
628 j++;
629 }
2e33101f 630
19998dbc
JA		 631 gtk_list_store_set(model, &iter, i, fbuf, -1);
632 }
2e33101f 633
19998dbc 634}
2e33101f 635
19998dbc
JA		 636static void gfio_add_total_depths_tree(GtkListStore *model,
637 struct thread_stat *ts, unsigned int len)
638{
639 double io_u_dist[FIO_IO_U_MAP_NR];
640 GtkTreeIter iter;
641 /* Bits 1-6, and 8 */
642 const int add_mask = 0x17e;
643 int i, j;
644
645 stat_calc_dist(ts->io_u_map, ts_total_io_u(ts), io_u_dist);
2e33101f
JA		 646
647 gtk_list_store_append(model, &iter);
648
19998dbc
JA		 649 gtk_list_store_set(model, &iter, 0, "Total", -1);
650
651 for (i = 1, j = 0; i < len; i++) {
2e33101f
JA		 652 char fbuf[32];
653
19998dbc
JA		 654 if (!(add_mask & (1UL << (i - 1))))
655 sprintf(fbuf, "0.0%%");
656 else {
657 sprintf(fbuf, "%3.1f%%", io_u_dist[j]);
658 j++;
2e33101f
JA		 659 }
660
2e33101f
JA		 661 gtk_list_store_set(model, &iter, i, fbuf, -1);
662 }
663
19998dbc 664}
2e33101f 665
19998dbc
JA		 666static void gfio_show_io_depths(GtkWidget *vbox, struct thread_stat *ts)
667{
668 GtkWidget *frame, *box, *tree_view;
669 GtkTreeSelection *selection;
670 GtkListStore *model;
671 GType types[FIO_IO_U_MAP_NR + 1];
672 int i;
673#define NR_LABELS 10
674 const char *labels[NR_LABELS] = { "Depth", "0", "1", "2", "4", "8", "16", "32", "64", ">= 64" };
2e33101f 675
19998dbc
JA		 676 frame = gtk_frame_new("IO depths");
677 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
2e33101f 678
19998dbc
JA		 679 box = gtk_hbox_new(FALSE, 3);
680 gtk_container_add(GTK_CONTAINER(frame), box);
2e33101f 681
19998dbc
JA		 682 for (i = 0; i < NR_LABELS; i++)
683 types[i] = G_TYPE_STRING;
2e33101f 684
19998dbc 685 model = gtk_list_store_newv(NR_LABELS, types);
2e33101f 686
19998dbc
JA		 687 tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
688 gtk_widget_set_can_focus(tree_view, FALSE);
2e33101f 689
19998dbc
JA		 690 selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
691 gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
692
693 for (i = 0; i < NR_LABELS; i++)
694 tree_view_column(tree_view, i, labels[i], ALIGN_RIGHT | UNSORTABLE);
695
696 gfio_add_total_depths_tree(model, ts, NR_LABELS);
697 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 1);
698 gfio_add_sc_depths_tree(model, ts, NR_LABELS, 0);
2e33101f
JA		 699
700 gtk_box_pack_start(GTK_BOX(box), tree_view, TRUE, FALSE, 3);
701}
702
3650a3ca
JA		 703static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
704 struct group_run_stats *rs)
705{
706 GtkWidget *dialog, *box, *vbox, *entry, *content;
707 struct gui *ui = client->client_data;
708
709 gdk_threads_enter();
710
711 dialog = gtk_dialog_new_with_buttons("Results", GTK_WINDOW(ui->window),
712 GTK_DIALOG_DESTROY_WITH_PARENT,
713 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
714
715 g_signal_connect_swapped(dialog, "response",
716 G_CALLBACK(gtk_widget_destroy),
717 dialog);
718
719 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
720
721 vbox = gtk_vbox_new(FALSE, 3);
722 gtk_container_add(GTK_CONTAINER(content), vbox);
723
724 box = gtk_hbox_new(TRUE, 3);
725 gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
726
727 entry = new_info_entry_in_frame(box, "Name");
728 gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
729 if (strlen(ts->description)) {
730 entry = new_info_entry_in_frame(box, "Description");
731 gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
732 }
733 entry = new_info_entry_in_frame(box, "Group ID");
734 entry_set_int_value(entry, ts->groupid);
735 entry = new_info_entry_in_frame(box, "Jobs");
736 entry_set_int_value(entry, ts->members);
737 entry = new_info_entry_in_frame(box, "Error");
738 entry_set_int_value(entry, ts->error);
739 entry = new_info_entry_in_frame(box, "PID");
740 entry_set_int_value(entry, ts->pid);
741
742 if (ts->io_bytes[DDIR_READ])
743 gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
744 if (ts->io_bytes[DDIR_WRITE])
745 gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
746
e5bd1347 747 gfio_show_latency_buckets(vbox, ts);
2e33101f
JA		 748 gfio_show_cpu_usage(vbox, ts);
749 gfio_show_io_depths(vbox, ts);
e5bd1347 750
3650a3ca 751 gtk_widget_show_all(dialog);
3650a3ca
JA		 752 gdk_threads_leave();
753}
754
084d1c6f 755static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
a1820207 756{
807f9971 757#if 0
736f2dff
SC		 758 GtkTextBuffer *buffer;
759 GtkTextIter end;
760
761 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui.textview));
762 gdk_threads_enter();
763 gtk_text_buffer_get_end_iter(buffer, &end);
764 gtk_text_buffer_insert(buffer, &end, buf, -1);
765 gdk_threads_leave();
766 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ui.textview),
767 &end, 0.0, FALSE, 0.0,0.0);
807f9971 768#else
084d1c6f 769 fio_client_ops.text_op(client, cmd);
807f9971 770#endif
a1820207
SC		 771}
772
773static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
774{
775 printf("gfio_disk_util_op called\n");
776 fio_client_ops.disk_util(client, cmd);
777}
778
3650a3ca
JA		 779extern int sum_stat_clients;
780extern struct thread_stat client_ts;
781extern struct group_run_stats client_gs;
782
783static int sum_stat_nr;
784
89e5fad9
JA		 785static void gfio_thread_status_op(struct fio_client *client,
786 struct fio_net_cmd *cmd)
a1820207 787{
3650a3ca
JA		 788 struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
789
790 gfio_display_ts(client, &p->ts, &p->rs);
791
792 if (sum_stat_clients == 1)
793 return;
794
795 sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
796 sum_group_stats(&client_gs, &p->rs);
797
798 client_ts.members++;
799 client_ts.groupid = p->ts.groupid;
800
801 if (++sum_stat_nr == sum_stat_clients) {
802 strcpy(client_ts.name, "All clients");
803 gfio_display_ts(client, &client_ts, &client_gs);
804 }
a1820207
SC		 805}
806
89e5fad9
JA		 807static void gfio_group_stats_op(struct fio_client *client,
808 struct fio_net_cmd *cmd)
a1820207
SC		 809{
810 printf("gfio_group_stats_op called\n");
89e5fad9 811 fio_client_ops.group_stats(client, cmd);
a1820207
SC		 812}
813
3e47bd25
JA		 814static void gfio_update_eta(struct jobs_eta *je)
815{
816 static int eta_good;
817 char eta_str[128];
818 char output[256];
819 char tmp[32];
820 double perc = 0.0;
821 int i2p = 0;
822
823 eta_str[0] = '\0';
824 output[0] = '\0';
825
826 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
827 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
828 eta_to_str(eta_str, je->eta_sec);
829 }
830
831 sprintf(tmp, "%u", je->nr_running);
ca850992 832 gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
3e47bd25 833 sprintf(tmp, "%u", je->files_open);
ca850992 834 gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
3e47bd25
JA		 835
836#if 0
837 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
838 if (je->m_rate || je->t_rate) {
839 char *tr, *mr;
840
841 mr = num2str(je->m_rate, 4, 0, i2p);
842 tr = num2str(je->t_rate, 4, 0, i2p);
ca850992 843 gtk_entry_set_text(GTK_ENTRY(ui.eta);
3e47bd25
JA		 844 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
845 free(tr);
846 free(mr);
847 } else if (je->m_iops || je->t_iops)
848 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
ebbd89cc 849
ca850992
JA		 850 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
851 gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
852 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
853 gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
3e47bd25
JA		 854#endif
855
856 if (je->eta_sec != INT_MAX && je->nr_running) {
857 char *iops_str[2];
858 char *rate_str[2];
859
860 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
861 strcpy(output, "-.-% done");
862 else {
863 eta_good = 1;
864 perc *= 100.0;
865 sprintf(output, "%3.1f%% done", perc);
866 }
867
868 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
869 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
870
871 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
872 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
873
ca850992
JA		 874 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
875 gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
876 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
877 gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
3e47bd25
JA		 878
879 free(rate_str[0]);
880 free(rate_str[1]);
881 free(iops_str[0]);
882 free(iops_str[1]);
883 }
884
885 if (eta_str[0]) {
886 char *dst = output + strlen(output);
887
888 sprintf(dst, " - %s", eta_str);
889 }
890
891 gfio_update_thread_status(output, perc);
892}
893
a1820207
SC		 894static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
895{
843ad237
JA		 896 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
897 const char *os, *arch;
898 char buf[64];
899
900 os = fio_get_os_string(probe->os);
901 if (!os)
902 os = "unknown";
903
904 arch = fio_get_arch_string(probe->arch);
905 if (!arch)
906 os = "unknown";
907
908 if (!client->name)
909 client->name = strdup((char *) probe->hostname);
910
911 gtk_label_set_text(GTK_LABEL(ui.probe.hostname), (char *) probe->hostname);
912 gtk_label_set_text(GTK_LABEL(ui.probe.os), os);
913 gtk_label_set_text(GTK_LABEL(ui.probe.arch), arch);
914 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
915 gtk_label_set_text(GTK_LABEL(ui.probe.fio_ver), buf);
a1820207
SC		 916}
917
04cc6b77 918static void gfio_update_thread_status(char *status_message, double perc)
5b7573ab
SC		 919{
920 static char message[100];
921 const char *m = message;
922
923 strncpy(message, status_message, sizeof(message) - 1);
04cc6b77
SC		 924 gtk_progress_bar_set_text(
925 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
926 gtk_progress_bar_set_fraction(
927 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
5b7573ab
SC		 928 gdk_threads_enter();
929 gtk_widget_queue_draw(ui.window);
930 gdk_threads_leave();
931}
932
3ec62ec4
JA		 933static void gfio_quit_op(struct fio_client *client)
934{
935 struct gui *ui = client->client_data;
936
937 gfio_set_connected(ui, 0);
938}
939
807f9971
JA		 940static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
941{
942 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
943 struct gui *ui = client->client_data;
944 char tmp[8];
945 int i;
946
947 p->iodepth = le32_to_cpu(p->iodepth);
948 p->rw = le32_to_cpu(p->rw);
949
950 for (i = 0; i < 2; i++) {
951 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
952 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
953 }
954
955 p->numjobs = le32_to_cpu(p->numjobs);
956 p->group_reporting = le32_to_cpu(p->group_reporting);
957
ca850992
JA		 958 gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
959 gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
960 gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
807f9971
JA		 961
962 sprintf(tmp, "%u", p->iodepth);
ca850992 963 gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
807f9971
JA		 964}
965
ed727a46
JA		 966static void gfio_client_timed_out(struct fio_client *client)
967{
968 struct gui *ui = client->client_data;
969 GtkWidget *dialog, *label, *content;
970 char buf[256];
971
972 gdk_threads_enter();
973
974 gfio_set_connected(ui, 0);
88432651 975 clear_ui_info(ui);
ed727a46
JA		 976
977 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
978
979 dialog = gtk_dialog_new_with_buttons("Timed out!",
980 GTK_WINDOW(ui->window),
981 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
982 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
983
984 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
985 label = gtk_label_new((const gchar *) buf);
986 gtk_container_add(GTK_CONTAINER(content), label);
987 gtk_widget_show_all(dialog);
988 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
989
990 gtk_dialog_run(GTK_DIALOG(dialog));
991 gtk_widget_destroy(dialog);
992
993 gdk_threads_leave();
994}
995
a1820207 996struct client_ops gfio_client_ops = {
0420ba6a
JA		 997 .text_op = gfio_text_op,
998 .disk_util = gfio_disk_util_op,
999 .thread_status = gfio_thread_status_op,
1000 .group_stats = gfio_group_stats_op,
a5276616 1001 .eta = gfio_update_eta,
0420ba6a 1002 .probe = gfio_probe_op,
3ec62ec4 1003 .quit = gfio_quit_op,
807f9971 1004 .add_job = gfio_add_job_op,
ed727a46 1005 .timed_out = gfio_client_timed_out,
3ec62ec4 1006 .stay_connected = 1,
a1820207
SC		 1007};
1008
ff1f3280
SC		 1009static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
1010 __attribute__((unused)) gpointer data)
1011{
1012 gtk_main_quit();
1013}
1014
25927259
SC		 1015static void *job_thread(void *arg)
1016{
25927259 1017 fio_handle_clients(&gfio_client_ops);
25927259
SC		 1018 return NULL;
1019}
1020
0420ba6a 1021static int send_job_files(struct gui *ui)
60f6b330 1022{
441013b4 1023 int i, ret = 0;
0420ba6a
JA		 1024
1025 for (i = 0; i < ui->nr_job_files; i++) {
1026 ret = fio_clients_send_ini(ui->job_files[i]);
441013b4
JA		 1027 if (ret)
1028 break;
1029
0420ba6a
JA		 1030 free(ui->job_files[i]);
1031 ui->job_files[i] = NULL;
441013b4
JA		 1032 }
1033 while (i < ui->nr_job_files) {
1034 free(ui->job_files[i]);
1035 ui->job_files[i] = NULL;
1036 i++;
0420ba6a
JA		 1037 }
1038
441013b4 1039 return ret;
60f6b330
SC		 1040}
1041
3ec62ec4 1042static void start_job_thread(struct gui *ui)
25927259 1043{
0420ba6a 1044 if (send_job_files(ui)) {
60f6b330 1045 printf("Yeah, I didn't really like those options too much.\n");
60f6b330
SC		 1046 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
1047 return;
1048 }
25927259
SC		 1049}
1050
f3074008 1051static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
25927259 1052 gpointer data)
f3074008 1053{
25927259
SC		 1054 struct gui *ui = data;
1055
25927259 1056 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
3ec62ec4 1057 start_job_thread(ui);
f3074008
SC		 1058}
1059
df06f220
JA		 1060static void file_open(GtkWidget *w, gpointer data);
1061
1062static void connect_clicked(GtkWidget *widget, gpointer data)
3e47bd25 1063{
3ec62ec4
JA		 1064 struct gui *ui = data;
1065
1066 if (!ui->connected) {
df06f220
JA		 1067 if (!ui->nr_job_files)
1068 file_open(widget, data);
8663ea65 1069 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
3ec62ec4
JA		 1070 fio_clients_connect();
1071 pthread_create(&ui->t, NULL, job_thread, NULL);
1072 gfio_set_connected(ui, 1);
df06f220
JA		 1073 } else {
1074 fio_clients_terminate();
3ec62ec4 1075 gfio_set_connected(ui, 0);
88432651 1076 clear_ui_info(ui);
df06f220 1077 }
3e47bd25
JA		 1078}
1079
f3074008
SC		 1080static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
1081 struct button_spec *buttonspec)
1082{
1083 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
1084 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
3ec62ec4 1085 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
f3074008 1086 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
3e47bd25 1087 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
f3074008
SC		 1088}
1089
1090static void add_buttons(struct gui *ui,
1091 struct button_spec *buttonlist,
1092 int nbuttons)
1093{
1094 int i;
1095
f3074008
SC		 1096 for (i = 0; i < nbuttons; i++)
1097 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
1098}
1099
0420ba6a
JA		 1100static void on_info_bar_response(GtkWidget *widget, gint response,
1101 gpointer data)
1102{
1103 if (response == GTK_RESPONSE_OK) {
1104 gtk_widget_destroy(widget);
1105 ui.error_info_bar = NULL;
1106 }
1107}
1108
df06f220 1109void report_error(GError *error)
0420ba6a
JA		 1110{
1111 if (ui.error_info_bar == NULL) {
1112 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
1113 GTK_RESPONSE_OK,
1114 NULL);
1115 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
1116 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
1117 GTK_MESSAGE_ERROR);
1118
1119 ui.error_label = gtk_label_new(error->message);
1120 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
1121 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
1122
1123 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
1124 gtk_widget_show_all(ui.vbox);
1125 } else {
1126 char buffer[256];
1127 snprintf(buffer, sizeof(buffer), "Failed to open file.");
1128 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
1129 }
1130}
1131
b9f3c7ed
JA		 1132static int get_connection_details(char **host, int *port, int *type,
1133 int *server_start)
a7a42ce1
JA		 1134{
1135 GtkWidget *dialog, *box, *vbox, *hentry, *hbox, *frame, *pentry, *combo;
b9f3c7ed 1136 GtkWidget *button;
a7a42ce1
JA		 1137 char *typeentry;
1138
1139 dialog = gtk_dialog_new_with_buttons("Connection details",
1140 GTK_WINDOW(ui.window),
1141 GTK_DIALOG_DESTROY_WITH_PARENT,
1142 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1143 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
1144
1145 frame = gtk_frame_new("Hostname / socket name");
1146 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
1147 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1148
1149 box = gtk_vbox_new(FALSE, 6);
1150 gtk_container_add(GTK_CONTAINER(frame), box);
1151
1152 hbox = gtk_hbox_new(TRUE, 10);
1153 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1154 hentry = gtk_entry_new();
1155 gtk_entry_set_text(GTK_ENTRY(hentry), "localhost");
1156 gtk_box_pack_start(GTK_BOX(hbox), hentry, TRUE, TRUE, 0);
1157
1158 frame = gtk_frame_new("Port");
1159 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1160 box = gtk_vbox_new(FALSE, 10);
1161 gtk_container_add(GTK_CONTAINER(frame), box);
1162
1163 hbox = gtk_hbox_new(TRUE, 4);
1164 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1165 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
1166
1167 frame = gtk_frame_new("Type");
1168 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1169 box = gtk_vbox_new(FALSE, 10);
1170 gtk_container_add(GTK_CONTAINER(frame), box);
1171
1172 hbox = gtk_hbox_new(TRUE, 4);
1173 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1174
1175 combo = gtk_combo_box_text_new();
1176 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv4");
1177 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv6");
1178 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "local socket");
1179 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
1180
1181 gtk_container_add(GTK_CONTAINER(hbox), combo);
1182
b9f3c7ed
JA		 1183 frame = gtk_frame_new("Options");
1184 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
1185 box = gtk_vbox_new(FALSE, 10);
1186 gtk_container_add(GTK_CONTAINER(frame), box);
1187
1188 hbox = gtk_hbox_new(TRUE, 4);
1189 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
1190
1191 button = gtk_check_button_new_with_label("Auto-spawn fio backend");
1192 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
1193 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.");
1194 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 6);
1195
a7a42ce1
JA		 1196 gtk_widget_show_all(dialog);
1197
1198 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1199 gtk_widget_destroy(dialog);
1200 return 1;
1201 }
1202
1203 *host = strdup(gtk_entry_get_text(GTK_ENTRY(hentry)));
1204 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
1205
1206 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
1207 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
1208 *type = Fio_client_ipv4;
1209 else if (!strncmp(typeentry, "IPv6", 4))
1210 *type = Fio_client_ipv6;
1211 else
1212 *type = Fio_client_socket;
1213 g_free(typeentry);
1214
b9f3c7ed
JA		 1215 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
1216
a7a42ce1
JA		 1217 gtk_widget_destroy(dialog);
1218 return 0;
1219}
1220
0420ba6a
JA		 1221static void file_open(GtkWidget *w, gpointer data)
1222{
1223 GtkWidget *dialog;
1224 GSList *filenames, *fn_glist;
1225 GtkFileFilter *filter;
a7a42ce1 1226 char *host;
b9f3c7ed 1227 int port, type, server_start;
0420ba6a
JA		 1228
1229 dialog = gtk_file_chooser_dialog_new("Open File",
1230 GTK_WINDOW(ui.window),
1231 GTK_FILE_CHOOSER_ACTION_OPEN,
1232 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1233 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
1234 NULL);
1235 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
1236
1237 filter = gtk_file_filter_new();
1238 gtk_file_filter_add_pattern(filter, "*.fio");
1239 gtk_file_filter_add_pattern(filter, "*.job");
1240 gtk_file_filter_add_mime_type(filter, "text/fio");
1241 gtk_file_filter_set_name(filter, "Fio job file");
1242 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
1243
1244 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1245 gtk_widget_destroy(dialog);
1246 return;
1247 }
1248
1249 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
a7a42ce1
JA		 1250
1251 gtk_widget_destroy(dialog);
1252
b9f3c7ed 1253 if (get_connection_details(&host, &port, &type, &server_start))
a7a42ce1
JA		 1254 goto err;
1255
0420ba6a
JA		 1256 filenames = fn_glist;
1257 while (filenames != NULL) {
0420ba6a
JA		 1258 ui.job_files = realloc(ui.job_files, (ui.nr_job_files + 1) * sizeof(char *));
1259 ui.job_files[ui.nr_job_files] = strdup(filenames->data);
1260 ui.nr_job_files++;
1261
a5276616 1262 ui.client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
df06f220
JA		 1263 if (!ui.client) {
1264 GError *error;
1265
1266 error = g_error_new(g_quark_from_string("fio"), 1,
1267 "Failed to add client %s", host);
0420ba6a
JA		 1268 report_error(error);
1269 g_error_free(error);
0420ba6a 1270 }
df06f220 1271 ui.client->client_data = &ui;
0420ba6a
JA		 1272
1273 g_free(filenames->data);
1274 filenames = g_slist_next(filenames);
1275 }
a7a42ce1
JA		 1276 free(host);
1277err:
0420ba6a 1278 g_slist_free(fn_glist);
0420ba6a
JA		 1279}
1280
1281static void file_save(GtkWidget *w, gpointer data)
1282{
1283 GtkWidget *dialog;
1284
1285 dialog = gtk_file_chooser_dialog_new("Save File",
1286 GTK_WINDOW(ui.window),
1287 GTK_FILE_CHOOSER_ACTION_SAVE,
1288 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
1289 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
1290 NULL);
1291
1292 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
1293 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
1294
1295 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
1296 char *filename;
1297
1298 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
1299 // save_job_file(filename);
1300 g_free(filename);
1301 }
1302 gtk_widget_destroy(dialog);
1303}
1304
46974a7d
JA		 1305static void preferences(GtkWidget *w, gpointer data)
1306{
1307 GtkWidget *dialog, *frame, *box, **buttons;
1308 int i;
1309
1310 dialog = gtk_dialog_new_with_buttons("Preferences",
1311 GTK_WINDOW(ui.window),
1312 GTK_DIALOG_DESTROY_WITH_PARENT,
1313 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
1314 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
1315 NULL);
1316
0b8d11ed 1317 frame = gtk_frame_new("Debug logging");
46974a7d
JA		 1318 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
1319 box = gtk_hbox_new(FALSE, 6);
1320 gtk_container_add(GTK_CONTAINER(frame), box);
1321
1322 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
1323
1324 for (i = 0; i < FD_DEBUG_MAX; i++) {
1325 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
0b8d11ed 1326 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
46974a7d
JA		 1327 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
1328 }
1329
1330 gtk_widget_show_all(dialog);
1331
1332 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
1333 gtk_widget_destroy(dialog);
1334 return;
1335 }
1336
1337 for (i = 0; i < FD_DEBUG_MAX; i++) {
1338 int set;
1339
1340 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
1341 if (set)
1342 fio_debug |= (1UL << i);
1343 }
1344
1345 gtk_widget_destroy(dialog);
1346}
1347
0420ba6a
JA		 1348static void about_dialog(GtkWidget *w, gpointer data)
1349{
1350 gtk_show_about_dialog(NULL,
1351 "program-name", "gfio",
1352 "comments", "Gtk2 UI for fio",
1353 "license", "GPLv2",
1354 "version", fio_version_string,
1355 "copyright", "Jens Axboe <axboe@kernel.dk> 2012",
1356 "logo-icon-name", "fio",
1357 /* Must be last: */
1358 NULL, NULL,
1359 NULL);
1360}
1361
1362static GtkActionEntry menu_items[] = {
46974a7d
JA		 1363 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
1364 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
1365 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
1366 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
1367 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
1368 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
1369 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
0420ba6a 1370};
3e47bd25 1371static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
0420ba6a
JA		 1372
1373static const gchar *ui_string = " \
1374 <ui> \
1375 <menubar name=\"MainMenu\"> \
1376 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
1377 <menuitem name=\"Open\" action=\"OpenFile\" /> \
1378 <menuitem name=\"Save\" action=\"SaveFile\" /> \
1379 <separator name=\"Separator\"/> \
46974a7d
JA		 1380 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
1381 <separator name=\"Separator2\"/> \
0420ba6a
JA		 1382 <menuitem name=\"Quit\" action=\"Quit\" /> \
1383 </menu> \
1384 <menu name=\"Help\" action=\"HelpMenuAction\"> \
1385 <menuitem name=\"About\" action=\"About\" /> \
1386 </menu> \
1387 </menubar> \
1388 </ui> \
1389";
1390
1391static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager)
1392{
1393 GtkActionGroup *action_group = gtk_action_group_new("Menu");
1394 GError *error = 0;
1395
1396 action_group = gtk_action_group_new("Menu");
1397 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
1398
1399 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
1400 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
1401
1402 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
1403 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
1404}
1405
1406void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
1407 GtkWidget *vbox, GtkUIManager *ui_manager)
1408{
1409 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
1410}
1411
ff1f3280
SC		 1412static void init_ui(int *argc, char **argv[], struct gui *ui)
1413{
0420ba6a
JA		 1414 GtkSettings *settings;
1415 GtkUIManager *uimanager;
843ad237 1416 GtkWidget *menu, *probe, *probe_frame, *probe_box;
0420ba6a
JA		 1417
1418 memset(ui, 0, sizeof(*ui));
45032dd8 1419
2839f0c6 1420 /* Magical g*thread incantation, you just need this thread stuff.
04cc6b77 1421 * Without it, the update that happens in gfio_update_thread_status
2839f0c6
SC		 1422 * doesn't really happen in a timely fashion, you need expose events
1423 */
ed727a46 1424 if (!g_thread_supported())
2839f0c6
SC		 1425 g_thread_init(NULL);
1426 gdk_threads_init();
1427
ff1f3280 1428 gtk_init(argc, argv);
0420ba6a
JA		 1429 settings = gtk_settings_get_default();
1430 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
1431 g_type_init();
ff1f3280
SC		 1432
1433 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1434 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
1435 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 500);
1436
0420ba6a
JA		 1437 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
1438 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
ff1f3280 1439
5b7573ab
SC		 1440 ui->vbox = gtk_vbox_new(FALSE, 0);
1441 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
04cc6b77 1442
0420ba6a
JA		 1443 uimanager = gtk_ui_manager_new();
1444 menu = get_menubar_menu(ui->window, uimanager);
1445 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
1446
c36f98d9
SC		 1447 /*
1448 * Set up alignments for widgets at the top of ui,
1449 * align top left, expand horizontally but not vertically
1450 */
1451 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
3ec62ec4 1452 ui->topvbox = gtk_vbox_new(FALSE, 3);
c36f98d9 1453 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
e164534f 1454 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
c36f98d9 1455
3e47bd25 1456 probe = gtk_frame_new("Job");
843ad237
JA		 1457 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
1458 probe_frame = gtk_vbox_new(FALSE, 3);
1459 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
1460
1461 probe_box = gtk_hbox_new(FALSE, 3);
1462 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
843ad237
JA		 1463 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
1464 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
1465 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
1466 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
1467
3e47bd25
JA		 1468 probe_box = gtk_hbox_new(FALSE, 3);
1469 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971 1470
ca850992
JA		 1471 ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
1472 ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
1473 ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
1474 ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
1475 ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
1476 ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
3e47bd25
JA		 1477
1478 probe_box = gtk_hbox_new(FALSE, 3);
1479 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
ca850992
JA		 1480 ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
1481 ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
1482 ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
1483 ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
3e47bd25 1484
807f9971
JA		 1485 /*
1486 * Only add this if we have a commit rate
1487 */
1488#if 0
3e47bd25
JA		 1489 probe_box = gtk_hbox_new(FALSE, 3);
1490 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
807f9971
JA		 1491
1492 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
1493 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
1494
3e47bd25
JA		 1495 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
1496 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
807f9971 1497#endif
3e47bd25 1498
736f2dff
SC		 1499 /*
1500 * Add a text box for text op messages
1501 */
1502 ui->textview = gtk_text_view_new();
1503 ui->text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui->textview));
1504 gtk_text_buffer_set_text(ui->text, "", -1);
1505 gtk_text_view_set_editable(GTK_TEXT_VIEW(ui->textview), FALSE);
1506 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ui->textview), FALSE);
1507 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
1508 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
1509 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1510 gtk_container_add(GTK_CONTAINER(ui->scrolled_window), ui->textview);
e164534f
SC		 1511 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
1512 TRUE, TRUE, 0);
736f2dff 1513
c36f98d9
SC		 1514 /*
1515 * Set up alignments for widgets at the bottom of ui,
1516 * align bottom left, expand horizontally but not vertically
1517 */
1518 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
1519 ui->buttonbox = gtk_hbox_new(FALSE, 0);
1520 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
e164534f
SC		 1521 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
1522 FALSE, FALSE, 0);
c36f98d9 1523
f3074008 1524 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
3ec62ec4
JA		 1525
1526 /*
1527 * Set up thread status progress bar
1528 */
1529 ui->thread_status_pb = gtk_progress_bar_new();
1530 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
8663ea65 1531 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
3ec62ec4
JA		 1532 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
1533
1534
ff1f3280
SC		 1535 gtk_widget_show_all(ui->window);
1536}
1537
8232e285 1538int main(int argc, char *argv[], char *envp[])
ff1f3280 1539{
8232e285
SC		 1540 if (initialize_fio(envp))
1541 return 1;
0420ba6a
JA		 1542 if (fio_init_options())
1543 return 1;
a1820207 1544
ff1f3280 1545 init_ui(&argc, &argv, &ui);
5b7573ab 1546
2839f0c6 1547 gdk_threads_enter();
ff1f3280 1548 gtk_main();
2839f0c6 1549 gdk_threads_leave();
ff1f3280
SC		 1550 return 0;
1551}
fio - Flexible IO Tester