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