projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
stat: move calc of latencies into show function
[fio.git] / gfio.c
... / ...
CommitLineData
1/*
2 * gfio - gui front end for fio - the flexible io tester
3 *
4 * Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
5 *
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 */
23#include <locale.h>
24#include <malloc.h>
25
26#include <glib.h>
27#include <gtk/gtk.h>
28
29#include "fio.h"
30
31static void gfio_update_thread_status(char *status_message, double perc);
32
33#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
34
35typedef void (*clickfunction)(GtkWidget *widget, gpointer data);
36
37static void connect_clicked(GtkWidget *widget, gpointer data);
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;
44 const int start_insensitive;
45} buttonspeclist[] = {
46#define CONNECT_BUTTON 0
47#define START_JOB_BUTTON 1
48 { "Connect", connect_clicked, "Connect to host", 0 },
49 { "Start Job",
50 start_job_clicked,
51 "Send current fio job to fio server to be executed", 1 },
52};
53
54struct probe_widget {
55 GtkWidget *hostname;
56 GtkWidget *os;
57 GtkWidget *arch;
58 GtkWidget *fio_ver;
59};
60
61struct eta_widget {
62 GtkWidget *name;
63 GtkWidget *iotype;
64 GtkWidget *ioengine;
65 GtkWidget *iodepth;
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
78struct gui {
79 GtkWidget *window;
80 GtkWidget *vbox;
81 GtkWidget *topvbox;
82 GtkWidget *topalign;
83 GtkWidget *bottomalign;
84 GtkWidget *thread_status_pb;
85 GtkWidget *buttonbox;
86 GtkWidget *button[ARRAYSIZE(buttonspeclist)];
87 GtkWidget *scrolled_window;
88 GtkWidget *textview;
89 GtkWidget *error_info_bar;
90 GtkWidget *error_label;
91 GtkTextBuffer *text;
92 struct probe_widget probe;
93 struct eta_widget eta;
94 int connected;
95 pthread_t t;
96
97 struct fio_client *client;
98 int nr_job_files;
99 char **job_files;
100} ui;
101
102static void clear_ui_info(struct gui *ui)
103{
104 gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
105 gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
106 gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
107 gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
108 gtk_label_set_text(GTK_LABEL(ui->eta.name), "");
109 gtk_label_set_text(GTK_LABEL(ui->eta.iotype), "");
110 gtk_label_set_text(GTK_LABEL(ui->eta.ioengine), "");
111 gtk_label_set_text(GTK_LABEL(ui->eta.iodepth), "");
112 gtk_label_set_text(GTK_LABEL(ui->eta.jobs), "");
113 gtk_label_set_text(GTK_LABEL(ui->eta.files), "");
114 gtk_label_set_text(GTK_LABEL(ui->eta.read_bw), "");
115 gtk_label_set_text(GTK_LABEL(ui->eta.read_iops), "");
116 gtk_label_set_text(GTK_LABEL(ui->eta.write_bw), "");
117 gtk_label_set_text(GTK_LABEL(ui->eta.write_iops), "");
118}
119
120static void gfio_set_connected(struct gui *ui, int connected)
121{
122 if (connected) {
123 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
124 ui->connected = 1;
125 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
126 } else {
127 ui->connected = 0;
128 gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
129 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
130 }
131}
132
133static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
134{
135#if 0
136 GtkTextBuffer *buffer;
137 GtkTextIter end;
138
139 buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui.textview));
140 gdk_threads_enter();
141 gtk_text_buffer_get_end_iter(buffer, &end);
142 gtk_text_buffer_insert(buffer, &end, buf, -1);
143 gdk_threads_leave();
144 gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ui.textview),
145 &end, 0.0, FALSE, 0.0,0.0);
146#else
147 fio_client_ops.text_op(client, cmd);
148#endif
149}
150
151static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd)
152{
153 printf("gfio_disk_util_op called\n");
154 fio_client_ops.disk_util(client, cmd);
155}
156
157static void gfio_thread_status_op(struct fio_client *client,
158 struct fio_net_cmd *cmd)
159{
160 printf("gfio_thread_status_op called\n");
161 fio_client_ops.thread_status(client, cmd);
162}
163
164static void gfio_group_stats_op(struct fio_client *client,
165 struct fio_net_cmd *cmd)
166{
167 printf("gfio_group_stats_op called\n");
168 fio_client_ops.group_stats(client, cmd);
169}
170
171static void gfio_update_eta(struct jobs_eta *je)
172{
173 static int eta_good;
174 char eta_str[128];
175 char output[256];
176 char tmp[32];
177 double perc = 0.0;
178 int i2p = 0;
179
180 eta_str[0] = '\0';
181 output[0] = '\0';
182
183 if (je->eta_sec != INT_MAX && je->elapsed_sec) {
184 perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
185 eta_to_str(eta_str, je->eta_sec);
186 }
187
188 sprintf(tmp, "%u", je->nr_running);
189 gtk_label_set_text(GTK_LABEL(ui.eta.jobs), tmp);
190 sprintf(tmp, "%u", je->files_open);
191 gtk_label_set_text(GTK_LABEL(ui.eta.files), tmp);
192
193#if 0
194 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
195 if (je->m_rate || je->t_rate) {
196 char *tr, *mr;
197
198 mr = num2str(je->m_rate, 4, 0, i2p);
199 tr = num2str(je->t_rate, 4, 0, i2p);
200 gtk_label_set_text(GTK_LABEL(ui.eta.
201 p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
202 free(tr);
203 free(mr);
204 } else if (je->m_iops || je->t_iops)
205 p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
206
207 gtk_label_set_text(GTK_LABEL(ui.eta.cr_bw), "---");
208 gtk_label_set_text(GTK_LABEL(ui.eta.cr_iops), "---");
209 gtk_label_set_text(GTK_LABEL(ui.eta.cw_bw), "---");
210 gtk_label_set_text(GTK_LABEL(ui.eta.cw_iops), "---");
211#endif
212
213 if (je->eta_sec != INT_MAX && je->nr_running) {
214 char *iops_str[2];
215 char *rate_str[2];
216
217 if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
218 strcpy(output, "-.-% done");
219 else {
220 eta_good = 1;
221 perc *= 100.0;
222 sprintf(output, "%3.1f%% done", perc);
223 }
224
225 rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
226 rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
227
228 iops_str[0] = num2str(je->iops[0], 4, 1, 0);
229 iops_str[1] = num2str(je->iops[1], 4, 1, 0);
230
231 gtk_label_set_text(GTK_LABEL(ui.eta.read_bw), rate_str[0]);
232 gtk_label_set_text(GTK_LABEL(ui.eta.read_iops), iops_str[0]);
233 gtk_label_set_text(GTK_LABEL(ui.eta.write_bw), rate_str[1]);
234 gtk_label_set_text(GTK_LABEL(ui.eta.write_iops), iops_str[1]);
235
236 free(rate_str[0]);
237 free(rate_str[1]);
238 free(iops_str[0]);
239 free(iops_str[1]);
240 }
241
242 if (eta_str[0]) {
243 char *dst = output + strlen(output);
244
245 sprintf(dst, " - %s", eta_str);
246 }
247
248 gfio_update_thread_status(output, perc);
249}
250
251static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
252{
253 struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
254 const char *os, *arch;
255 char buf[64];
256
257 os = fio_get_os_string(probe->os);
258 if (!os)
259 os = "unknown";
260
261 arch = fio_get_arch_string(probe->arch);
262 if (!arch)
263 os = "unknown";
264
265 if (!client->name)
266 client->name = strdup((char *) probe->hostname);
267
268 gtk_label_set_text(GTK_LABEL(ui.probe.hostname), (char *) probe->hostname);
269 gtk_label_set_text(GTK_LABEL(ui.probe.os), os);
270 gtk_label_set_text(GTK_LABEL(ui.probe.arch), arch);
271 sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
272 gtk_label_set_text(GTK_LABEL(ui.probe.fio_ver), buf);
273}
274
275static void gfio_update_thread_status(char *status_message, double perc)
276{
277 static char message[100];
278 const char *m = message;
279
280 strncpy(message, status_message, sizeof(message) - 1);
281 gtk_progress_bar_set_text(
282 GTK_PROGRESS_BAR(ui.thread_status_pb), m);
283 gtk_progress_bar_set_fraction(
284 GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
285 gdk_threads_enter();
286 gtk_widget_queue_draw(ui.window);
287 gdk_threads_leave();
288}
289
290static void gfio_quit_op(struct fio_client *client)
291{
292 struct gui *ui = client->client_data;
293
294 gfio_set_connected(ui, 0);
295}
296
297static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd)
298{
299 struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
300 struct gui *ui = client->client_data;
301 char tmp[8];
302 int i;
303
304 p->iodepth = le32_to_cpu(p->iodepth);
305 p->rw = le32_to_cpu(p->rw);
306
307 for (i = 0; i < 2; i++) {
308 p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
309 p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
310 }
311
312 p->numjobs = le32_to_cpu(p->numjobs);
313 p->group_reporting = le32_to_cpu(p->group_reporting);
314
315 gtk_label_set_text(GTK_LABEL(ui->eta.name), (gchar *) p->jobname);
316 gtk_label_set_text(GTK_LABEL(ui->eta.iotype), ddir_str(p->rw));
317 gtk_label_set_text(GTK_LABEL(ui->eta.ioengine), (gchar *) p->ioengine);
318
319 sprintf(tmp, "%u", p->iodepth);
320 gtk_label_set_text(GTK_LABEL(ui->eta.iodepth), tmp);
321}
322
323static void gfio_client_timed_out(struct fio_client *client)
324{
325 struct gui *ui = client->client_data;
326 GtkWidget *dialog, *label, *content;
327 char buf[256];
328
329 gdk_threads_enter();
330
331 gfio_set_connected(ui, 0);
332 clear_ui_info(ui);
333
334 sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
335
336 dialog = gtk_dialog_new_with_buttons("Timed out!",
337 GTK_WINDOW(ui->window),
338 GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
339 GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
340
341 content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
342 label = gtk_label_new((const gchar *) buf);
343 gtk_container_add(GTK_CONTAINER(content), label);
344 gtk_widget_show_all(dialog);
345 gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
346
347 gtk_dialog_run(GTK_DIALOG(dialog));
348 gtk_widget_destroy(dialog);
349
350 gdk_threads_leave();
351}
352
353struct client_ops gfio_client_ops = {
354 .text_op = gfio_text_op,
355 .disk_util = gfio_disk_util_op,
356 .thread_status = gfio_thread_status_op,
357 .group_stats = gfio_group_stats_op,
358 .eta = gfio_update_eta,
359 .probe = gfio_probe_op,
360 .quit = gfio_quit_op,
361 .add_job = gfio_add_job_op,
362 .timed_out = gfio_client_timed_out,
363 .stay_connected = 1,
364};
365
366static void quit_clicked(__attribute__((unused)) GtkWidget *widget,
367 __attribute__((unused)) gpointer data)
368{
369 gtk_main_quit();
370}
371
372static void *job_thread(void *arg)
373{
374 fio_handle_clients(&gfio_client_ops);
375 return NULL;
376}
377
378static int send_job_files(struct gui *ui)
379{
380 int i, ret = 0;
381
382 for (i = 0; i < ui->nr_job_files; i++) {
383 ret = fio_clients_send_ini(ui->job_files[i]);
384 if (ret)
385 break;
386
387 free(ui->job_files[i]);
388 ui->job_files[i] = NULL;
389 }
390 while (i < ui->nr_job_files) {
391 free(ui->job_files[i]);
392 ui->job_files[i] = NULL;
393 i++;
394 }
395
396 return ret;
397}
398
399static void start_job_thread(struct gui *ui)
400{
401 if (send_job_files(ui)) {
402 printf("Yeah, I didn't really like those options too much.\n");
403 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
404 return;
405 }
406}
407
408static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
409{
410 GtkWidget *label_widget;
411 GtkWidget *frame;
412
413 frame = gtk_frame_new(label);
414 label_widget = gtk_label_new(NULL);
415 gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
416 gtk_container_add(GTK_CONTAINER(frame), label_widget);
417
418 return label_widget;
419}
420
421static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
422{
423 GtkWidget *button, *box;
424
425 box = gtk_hbox_new(FALSE, 3);
426 gtk_container_add(GTK_CONTAINER(hbox), box);
427
428 button = gtk_spin_button_new_with_range(min, max, 1.0);
429 gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
430
431 gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
432 gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
433
434 return button;
435}
436
437static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
438 gpointer data)
439{
440 struct gui *ui = data;
441
442 gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
443 start_job_thread(ui);
444}
445
446static void file_open(GtkWidget *w, gpointer data);
447
448static void connect_clicked(GtkWidget *widget, gpointer data)
449{
450 struct gui *ui = data;
451
452 if (!ui->connected) {
453 if (!ui->nr_job_files)
454 file_open(widget, data);
455 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
456 fio_clients_connect();
457 pthread_create(&ui->t, NULL, job_thread, NULL);
458 gfio_set_connected(ui, 1);
459 } else {
460 fio_clients_terminate();
461 gfio_set_connected(ui, 0);
462 clear_ui_info(ui);
463 }
464}
465
466static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
467 struct button_spec *buttonspec)
468{
469 ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
470 g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
471 gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
472 gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
473 gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
474}
475
476static void add_buttons(struct gui *ui,
477 struct button_spec *buttonlist,
478 int nbuttons)
479{
480 int i;
481
482 for (i = 0; i < nbuttons; i++)
483 add_button(ui, i, ui->buttonbox, &buttonlist[i]);
484}
485
486static void on_info_bar_response(GtkWidget *widget, gint response,
487 gpointer data)
488{
489 if (response == GTK_RESPONSE_OK) {
490 gtk_widget_destroy(widget);
491 ui.error_info_bar = NULL;
492 }
493}
494
495void report_error(GError *error)
496{
497 if (ui.error_info_bar == NULL) {
498 ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
499 GTK_RESPONSE_OK,
500 NULL);
501 g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
502 gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
503 GTK_MESSAGE_ERROR);
504
505 ui.error_label = gtk_label_new(error->message);
506 GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
507 gtk_container_add(GTK_CONTAINER(container), ui.error_label);
508
509 gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
510 gtk_widget_show_all(ui.vbox);
511 } else {
512 char buffer[256];
513 snprintf(buffer, sizeof(buffer), "Failed to open file.");
514 gtk_label_set(GTK_LABEL(ui.error_label), buffer);
515 }
516}
517
518static int get_connection_details(char **host, int *port, int *type,
519 int *server_start)
520{
521 GtkWidget *dialog, *box, *vbox, *hentry, *hbox, *frame, *pentry, *combo;
522 GtkWidget *button;
523 char *typeentry;
524
525 dialog = gtk_dialog_new_with_buttons("Connection details",
526 GTK_WINDOW(ui.window),
527 GTK_DIALOG_DESTROY_WITH_PARENT,
528 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
529 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
530
531 frame = gtk_frame_new("Hostname / socket name");
532 vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
533 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
534
535 box = gtk_vbox_new(FALSE, 6);
536 gtk_container_add(GTK_CONTAINER(frame), box);
537
538 hbox = gtk_hbox_new(TRUE, 10);
539 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
540 hentry = gtk_entry_new();
541 gtk_entry_set_text(GTK_ENTRY(hentry), "localhost");
542 gtk_box_pack_start(GTK_BOX(hbox), hentry, TRUE, TRUE, 0);
543
544 frame = gtk_frame_new("Port");
545 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
546 box = gtk_vbox_new(FALSE, 10);
547 gtk_container_add(GTK_CONTAINER(frame), box);
548
549 hbox = gtk_hbox_new(TRUE, 4);
550 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
551 pentry = create_spinbutton(hbox, 1, 65535, FIO_NET_PORT);
552
553 frame = gtk_frame_new("Type");
554 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
555 box = gtk_vbox_new(FALSE, 10);
556 gtk_container_add(GTK_CONTAINER(frame), box);
557
558 hbox = gtk_hbox_new(TRUE, 4);
559 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
560
561 combo = gtk_combo_box_text_new();
562 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv4");
563 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "IPv6");
564 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), "local socket");
565 gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
566
567 gtk_container_add(GTK_CONTAINER(hbox), combo);
568
569 frame = gtk_frame_new("Options");
570 gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
571 box = gtk_vbox_new(FALSE, 10);
572 gtk_container_add(GTK_CONTAINER(frame), box);
573
574 hbox = gtk_hbox_new(TRUE, 4);
575 gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
576
577 button = gtk_check_button_new_with_label("Auto-spawn fio backend");
578 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
579 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.");
580 gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 6);
581
582 gtk_widget_show_all(dialog);
583
584 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
585 gtk_widget_destroy(dialog);
586 return 1;
587 }
588
589 *host = strdup(gtk_entry_get_text(GTK_ENTRY(hentry)));
590 *port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
591
592 typeentry = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(combo));
593 if (!typeentry || !strncmp(typeentry, "IPv4", 4))
594 *type = Fio_client_ipv4;
595 else if (!strncmp(typeentry, "IPv6", 4))
596 *type = Fio_client_ipv6;
597 else
598 *type = Fio_client_socket;
599 g_free(typeentry);
600
601 *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
602
603 gtk_widget_destroy(dialog);
604 return 0;
605}
606
607static void file_open(GtkWidget *w, gpointer data)
608{
609 GtkWidget *dialog;
610 GSList *filenames, *fn_glist;
611 GtkFileFilter *filter;
612 char *host;
613 int port, type, server_start;
614
615 dialog = gtk_file_chooser_dialog_new("Open File",
616 GTK_WINDOW(ui.window),
617 GTK_FILE_CHOOSER_ACTION_OPEN,
618 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
619 GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
620 NULL);
621 gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
622
623 filter = gtk_file_filter_new();
624 gtk_file_filter_add_pattern(filter, "*.fio");
625 gtk_file_filter_add_pattern(filter, "*.job");
626 gtk_file_filter_add_mime_type(filter, "text/fio");
627 gtk_file_filter_set_name(filter, "Fio job file");
628 gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
629
630 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
631 gtk_widget_destroy(dialog);
632 return;
633 }
634
635 fn_glist = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
636
637 gtk_widget_destroy(dialog);
638
639 if (get_connection_details(&host, &port, &type, &server_start))
640 goto err;
641
642 filenames = fn_glist;
643 while (filenames != NULL) {
644 ui.job_files = realloc(ui.job_files, (ui.nr_job_files + 1) * sizeof(char *));
645 ui.job_files[ui.nr_job_files] = strdup(filenames->data);
646 ui.nr_job_files++;
647
648 ui.client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
649 if (!ui.client) {
650 GError *error;
651
652 error = g_error_new(g_quark_from_string("fio"), 1,
653 "Failed to add client %s", host);
654 report_error(error);
655 g_error_free(error);
656 }
657 ui.client->client_data = &ui;
658
659 g_free(filenames->data);
660 filenames = g_slist_next(filenames);
661 }
662 free(host);
663err:
664 g_slist_free(fn_glist);
665}
666
667static void file_save(GtkWidget *w, gpointer data)
668{
669 GtkWidget *dialog;
670
671 dialog = gtk_file_chooser_dialog_new("Save File",
672 GTK_WINDOW(ui.window),
673 GTK_FILE_CHOOSER_ACTION_SAVE,
674 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
675 GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
676 NULL);
677
678 gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
679 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
680
681 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
682 char *filename;
683
684 filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
685 // save_job_file(filename);
686 g_free(filename);
687 }
688 gtk_widget_destroy(dialog);
689}
690
691static void preferences(GtkWidget *w, gpointer data)
692{
693 GtkWidget *dialog, *frame, *box, **buttons;
694 int i;
695
696 dialog = gtk_dialog_new_with_buttons("Preferences",
697 GTK_WINDOW(ui.window),
698 GTK_DIALOG_DESTROY_WITH_PARENT,
699 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
700 GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
701 NULL);
702
703 frame = gtk_frame_new("Debug logging");
704 gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
705 box = gtk_hbox_new(FALSE, 6);
706 gtk_container_add(GTK_CONTAINER(frame), box);
707
708 buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
709
710 for (i = 0; i < FD_DEBUG_MAX; i++) {
711 buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
712 gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
713 gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
714 }
715
716 gtk_widget_show_all(dialog);
717
718 if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
719 gtk_widget_destroy(dialog);
720 return;
721 }
722
723 for (i = 0; i < FD_DEBUG_MAX; i++) {
724 int set;
725
726 set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
727 if (set)
728 fio_debug |= (1UL << i);
729 }
730
731 gtk_widget_destroy(dialog);
732}
733
734static void about_dialog(GtkWidget *w, gpointer data)
735{
736 gtk_show_about_dialog(NULL,
737 "program-name", "gfio",
738 "comments", "Gtk2 UI for fio",
739 "license", "GPLv2",
740 "version", fio_version_string,
741 "copyright", "Jens Axboe <axboe@kernel.dk> 2012",
742 "logo-icon-name", "fio",
743 /* Must be last: */
744 NULL, NULL,
745 NULL);
746}
747
748static GtkActionEntry menu_items[] = {
749 { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
750 { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
751 { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
752 { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
753 { "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
754 { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
755 { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
756};
757static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
758
759static const gchar *ui_string = " \
760 <ui> \
761 <menubar name=\"MainMenu\"> \
762 <menu name=\"FileMenu\" action=\"FileMenuAction\"> \
763 <menuitem name=\"Open\" action=\"OpenFile\" /> \
764 <menuitem name=\"Save\" action=\"SaveFile\" /> \
765 <separator name=\"Separator\"/> \
766 <menuitem name=\"Preferences\" action=\"Preferences\" /> \
767 <separator name=\"Separator2\"/> \
768 <menuitem name=\"Quit\" action=\"Quit\" /> \
769 </menu> \
770 <menu name=\"Help\" action=\"HelpMenuAction\"> \
771 <menuitem name=\"About\" action=\"About\" /> \
772 </menu> \
773 </menubar> \
774 </ui> \
775";
776
777static GtkWidget *get_menubar_menu(GtkWidget *window, GtkUIManager *ui_manager)
778{
779 GtkActionGroup *action_group = gtk_action_group_new("Menu");
780 GError *error = 0;
781
782 action_group = gtk_action_group_new("Menu");
783 gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
784
785 gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
786 gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
787
788 gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
789 return gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
790}
791
792void gfio_ui_setup(GtkSettings *settings, GtkWidget *menubar,
793 GtkWidget *vbox, GtkUIManager *ui_manager)
794{
795 gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
796}
797
798static void init_ui(int *argc, char **argv[], struct gui *ui)
799{
800 GtkSettings *settings;
801 GtkUIManager *uimanager;
802 GtkWidget *menu, *probe, *probe_frame, *probe_box;
803
804 memset(ui, 0, sizeof(*ui));
805
806 /* Magical g*thread incantation, you just need this thread stuff.
807 * Without it, the update that happens in gfio_update_thread_status
808 * doesn't really happen in a timely fashion, you need expose events
809 */
810 if (!g_thread_supported())
811 g_thread_init(NULL);
812 gdk_threads_init();
813
814 gtk_init(argc, argv);
815 settings = gtk_settings_get_default();
816 gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
817 g_type_init();
818
819 ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
820 gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
821 gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 500);
822
823 g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
824 g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
825
826 ui->vbox = gtk_vbox_new(FALSE, 0);
827 gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
828
829 uimanager = gtk_ui_manager_new();
830 menu = get_menubar_menu(ui->window, uimanager);
831 gfio_ui_setup(settings, menu, ui->vbox, uimanager);
832
833 /*
834 * Set up alignments for widgets at the top of ui,
835 * align top left, expand horizontally but not vertically
836 */
837 ui->topalign = gtk_alignment_new(0, 0, 1, 0);
838 ui->topvbox = gtk_vbox_new(FALSE, 3);
839 gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
840 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
841
842 probe = gtk_frame_new("Job");
843 gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
844 probe_frame = gtk_vbox_new(FALSE, 3);
845 gtk_container_add(GTK_CONTAINER(probe), probe_frame);
846
847 probe_box = gtk_hbox_new(FALSE, 3);
848 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
849 ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
850 ui->probe.os = new_info_label_in_frame(probe_box, "OS");
851 ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
852 ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
853
854 probe_box = gtk_hbox_new(FALSE, 3);
855 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
856
857 ui->eta.name = new_info_label_in_frame(probe_box, "Name");
858 ui->eta.iotype = new_info_label_in_frame(probe_box, "IO");
859 ui->eta.ioengine = new_info_label_in_frame(probe_box, "IO Engine");
860 ui->eta.iodepth = new_info_label_in_frame(probe_box, "IO Depth");
861 ui->eta.jobs = new_info_label_in_frame(probe_box, "Jobs");
862 ui->eta.files = new_info_label_in_frame(probe_box, "Open files");
863
864 probe_box = gtk_hbox_new(FALSE, 3);
865 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
866 ui->eta.read_bw = new_info_label_in_frame(probe_box, "Read BW");
867 ui->eta.read_iops = new_info_label_in_frame(probe_box, "IOPS");
868 ui->eta.write_bw = new_info_label_in_frame(probe_box, "Write BW");
869 ui->eta.write_iops = new_info_label_in_frame(probe_box, "IOPS");
870
871 /*
872 * Only add this if we have a commit rate
873 */
874#if 0
875 probe_box = gtk_hbox_new(FALSE, 3);
876 gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
877
878 ui->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
879 ui->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
880
881 ui->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
882 ui->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
883#endif
884
885 /*
886 * Add a text box for text op messages
887 */
888 ui->textview = gtk_text_view_new();
889 ui->text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui->textview));
890 gtk_text_buffer_set_text(ui->text, "", -1);
891 gtk_text_view_set_editable(GTK_TEXT_VIEW(ui->textview), FALSE);
892 gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ui->textview), FALSE);
893 ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
894 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
895 GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
896 gtk_container_add(GTK_CONTAINER(ui->scrolled_window), ui->textview);
897 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
898 TRUE, TRUE, 0);
899
900 /*
901 * Set up alignments for widgets at the bottom of ui,
902 * align bottom left, expand horizontally but not vertically
903 */
904 ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
905 ui->buttonbox = gtk_hbox_new(FALSE, 0);
906 gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
907 gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
908 FALSE, FALSE, 0);
909
910 add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
911
912 /*
913 * Set up thread status progress bar
914 */
915 ui->thread_status_pb = gtk_progress_bar_new();
916 gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), 0.0);
917 gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
918 gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
919
920
921 gtk_widget_show_all(ui->window);
922}
923
924int main(int argc, char *argv[], char *envp[])
925{
926 if (initialize_fio(envp))
927 return 1;
928 if (fio_init_options())
929 return 1;
930
931 init_ui(&argc, &argv, &ui);
932
933 gdk_threads_enter();
934 gtk_main();
935 gdk_threads_leave();
936 return 0;
937}
fio - Flexible IO Tester