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