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