* gfio - gui front end for fio - the flexible io tester
*
* Copyright (C) 2012 Stephen M. Cameron <stephenmcameron@gmail.com>
+ * Copyright (C) 2012 Jens Axboe <axboe@kernel.dk>
*
* The license below covers all files distributed with fio unless otherwise
* noted in the file itself.
*/
#include <locale.h>
#include <malloc.h>
+#include <string.h>
#include <glib.h>
+#include <cairo.h>
#include <gtk/gtk.h>
#include "fio.h"
+#include "graph.h"
-static void gfio_update_thread_status(char *status_message, double perc);
+static int gfio_server_running;
+static const char *gfio_graph_font;
+static unsigned int gfio_graph_limit = 100;
+
+static void view_log(GtkWidget *w, gpointer data);
#define ARRAYSIZE(x) (sizeof((x)) / (sizeof((x)[0])))
static void connect_clicked(GtkWidget *widget, gpointer data);
static void start_job_clicked(GtkWidget *widget, gpointer data);
+static void send_clicked(GtkWidget *widget, gpointer data);
static struct button_spec {
const char *buttontext;
const int start_insensitive;
} buttonspeclist[] = {
#define CONNECT_BUTTON 0
-#define START_JOB_BUTTON 1
+#define SEND_BUTTON 1
+#define START_JOB_BUTTON 2
{ "Connect", connect_clicked, "Connect to host", 0 },
- { "Start Job",
- start_job_clicked,
- "Send current fio job to fio server to be executed", 1 },
+ { "Send", send_clicked, "Send job description to host", 1 },
+ { "Start Job", start_job_clicked,
+ "Start the current job on the server", 1 },
};
struct probe_widget {
GtkWidget *fio_ver;
};
+struct multitext_widget {
+ GtkWidget *entry;
+ char **text;
+ unsigned int cur_text;
+ unsigned int max_text;
+};
+
struct eta_widget {
- GtkWidget *name;
- GtkWidget *iotype;
- GtkWidget *ioengine;
- GtkWidget *iodepth;
+ GtkWidget *names;
+ struct multitext_widget iotype;
+ struct multitext_widget ioengine;
+ struct multitext_widget iodepth;
GtkWidget *jobs;
GtkWidget *files;
GtkWidget *read_bw;
GtkWidget *cw_iops;
};
+struct gfio_graphs {
+#define DRAWING_AREA_XDIM 1000
+#define DRAWING_AREA_YDIM 400
+ GtkWidget *drawing_area;
+ struct graph *iops_graph;
+ struct graph *bandwidth_graph;
+};
+
+/*
+ * Main window widgets and data
+ */
struct gui {
GtkWidget *window;
GtkWidget *vbox;
GtkWidget *bottomalign;
GtkWidget *thread_status_pb;
GtkWidget *buttonbox;
+ GtkWidget *scrolled_window;
+ GtkWidget *notebook;
+ GtkWidget *error_info_bar;
+ GtkWidget *error_label;
+ GtkListStore *log_model;
+ GtkWidget *log_tree;
+ GtkWidget *log_view;
+ struct gfio_graphs graphs;
+ struct probe_widget probe;
+ struct eta_widget eta;
+ pthread_t server_t;
+
+ pthread_t t;
+ int handler_running;
+
+ struct flist_head list;
+} main_ui;
+
+/*
+ * Notebook entry
+ */
+struct gui_entry {
+ struct flist_head list;
+ struct gui *ui;
+
+ GtkWidget *vbox;
+ GtkWidget *topvbox;
+ GtkWidget *topalign;
+ GtkWidget *bottomalign;
+ GtkWidget *job_notebook;
+ GtkWidget *thread_status_pb;
+ GtkWidget *buttonbox;
GtkWidget *button[ARRAYSIZE(buttonspeclist)];
GtkWidget *scrolled_window;
- GtkWidget *textview;
+ GtkWidget *notebook;
GtkWidget *error_info_bar;
GtkWidget *error_label;
GtkWidget *results_notebook;
GtkListStore *log_model;
GtkWidget *log_tree;
GtkWidget *log_view;
- GtkTextBuffer *text;
+ struct gfio_graphs graphs;
struct probe_widget probe;
struct eta_widget eta;
+ GtkWidget *page_label;
+ gint page_num;
int connected;
- pthread_t t;
- struct fio_client *client;
+ struct gfio_client *client;
int nr_job_files;
char **job_files;
-} ui;
+};
struct gfio_client {
- struct gui *ui;
+ struct gui_entry *ge;
+ struct fio_client *client;
GtkWidget *results_widget;
GtkWidget *disk_util_frame;
+ GtkWidget *err_entry;
+ unsigned int job_added;
+ struct thread_options o;
};
-static void clear_ui_info(struct gui *ui)
+static void gfio_update_thread_status(struct gui_entry *ge, char *status_message, double perc);
+static void gfio_update_thread_status_all(char *status_message, double perc);
+void report_error(GError *error);
+
+static void iops_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
{
- gtk_label_set_text(GTK_LABEL(ui->probe.hostname), "");
- gtk_label_set_text(GTK_LABEL(ui->probe.os), "");
- gtk_label_set_text(GTK_LABEL(ui->probe.arch), "");
- gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.name), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.jobs), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.files), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), "");
- gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), "");
+ switch (power_of_ten) {
+ case 9: graph_y_title(g, "Billions of IOs / sec");
+ break;
+ case 6: graph_y_title(g, "Millions of IOs / sec");
+ break;
+ case 3: graph_y_title(g, "Thousands of IOs / sec");
+ break;
+ case 0:
+ default: graph_y_title(g, "IOs / sec");
+ break;
+ }
+}
+
+static struct graph *setup_iops_graph(void)
+{
+ struct graph *g;
+
+ g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(g, "IOPS");
+ graph_x_title(g, "Time (secs)");
+ graph_y_title(g, "IOs / sec");
+ graph_add_label(g, "Read IOPS");
+ graph_add_label(g, "Write IOPS");
+ graph_set_color(g, "Read IOPS", 0.13, 0.54, 0.13);
+ graph_set_color(g, "Write IOPS", 1.0, 0.0, 0.0);
+ line_graph_set_data_count_limit(g, gfio_graph_limit);
+ graph_y_axis_unit_change_notify(g, iops_graph_y_axis_unit_change);
+ graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
+ return g;
+}
+
+static void bandwidth_graph_y_axis_unit_change(struct graph *g, int power_of_ten)
+{
+ switch (power_of_ten) {
+ case 9: graph_y_title(g, "Petabytes / sec");
+ break;
+ case 6: graph_y_title(g, "Gigabytes / sec");
+ break;
+ case 3: graph_y_title(g, "Megabytes / sec");
+ break;
+ case 0:
+ default: graph_y_title(g, "Kilobytes / sec");
+ break;
+ }
+}
+
+static struct graph *setup_bandwidth_graph(void)
+{
+ struct graph *g;
+
+ g = graph_new(DRAWING_AREA_XDIM / 2.0, DRAWING_AREA_YDIM, gfio_graph_font);
+ graph_title(g, "Bandwidth");
+ graph_x_title(g, "Time (secs)");
+ graph_y_title(g, "Kbytes / sec");
+ graph_add_label(g, "Read Bandwidth");
+ graph_add_label(g, "Write Bandwidth");
+ graph_set_color(g, "Read Bandwidth", 0.13, 0.54, 0.13);
+ graph_set_color(g, "Write Bandwidth", 1.0, 0.0, 0.0);
+ line_graph_set_data_count_limit(g, 100);
+ graph_y_axis_unit_change_notify(g, bandwidth_graph_y_axis_unit_change);
+ graph_add_extra_space(g, 0.005, 0.005, 0.03, 0.03);
+
+ return g;
+}
+
+static void setup_graphs(struct gfio_graphs *g)
+{
+ g->iops_graph = setup_iops_graph();
+ g->bandwidth_graph = setup_bandwidth_graph();
+}
+
+static void multitext_add_entry(struct multitext_widget *mt, const char *text)
+{
+ mt->text = realloc(mt->text, (mt->max_text + 1) * sizeof(char *));
+ mt->text[mt->max_text] = strdup(text);
+ mt->max_text++;
+}
+
+static void multitext_set_entry(struct multitext_widget *mt, unsigned int index)
+{
+ if (index >= mt->max_text)
+ return;
+ if (!mt->text || !mt->text[index])
+ return;
+
+ mt->cur_text = index;
+ gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
+}
+
+static void multitext_update_entry(struct multitext_widget *mt,
+ unsigned int index, const char *text)
+{
+ if (!mt->text)
+ return;
+
+ if (mt->text[index])
+ free(mt->text[index]);
+
+ mt->text[index] = strdup(text);
+ if (mt->cur_text == index)
+ gtk_entry_set_text(GTK_ENTRY(mt->entry), mt->text[index]);
+}
+
+static void multitext_free(struct multitext_widget *mt)
+{
+ int i;
+
+ gtk_entry_set_text(GTK_ENTRY(mt->entry), "");
+
+ for (i = 0; i < mt->max_text; i++) {
+ if (mt->text[i])
+ free(mt->text[i]);
+ }
+
+ free(mt->text);
+ mt->cur_text = -1;
+ mt->max_text = 0;
+}
+
+static void clear_ge_ui_info(struct gui_entry *ge)
+{
+ gtk_label_set_text(GTK_LABEL(ge->probe.hostname), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.os), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.arch), "");
+ gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), "");
+#if 0
+ /* should we empty it... */
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.name), "");
+#endif
+ multitext_update_entry(&ge->eta.iotype, 0, "");
+ multitext_update_entry(&ge->eta.ioengine, 0, "");
+ multitext_update_entry(&ge->eta.iodepth, 0, "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.files), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), "");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), "");
+}
+
+static GtkWidget *new_combo_entry_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *entry, *frame;
+
+ frame = gtk_frame_new(label);
+ entry = gtk_combo_box_new_text();
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), entry);
+
+ return entry;
}
static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
return button;
}
-static void gfio_set_connected(struct gui *ui, int connected)
+static void gfio_set_connected(struct gui_entry *ge, int connected)
{
if (connected) {
- gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
- ui->connected = 1;
- gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Disconnect");
- gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 1);
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 1);
+ ge->connected = 1;
+ gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Disconnect");
+ gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 1);
} else {
- ui->connected = 0;
- gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
- gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
+ ge->connected = 0;
+ gtk_button_set_label(GTK_BUTTON(ge->button[CONNECT_BUTTON]), "Connect");
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 1);
}
}
static gboolean results_window_delete(GtkWidget *w, gpointer data)
{
- struct gui *ui = (struct gui *) data;
+ struct gui_entry *ge = (struct gui_entry *) data;
gtk_widget_destroy(w);
- ui->results_window = NULL;
- ui->results_notebook = NULL;
+ ge->results_window = NULL;
+ ge->results_notebook = NULL;
return TRUE;
}
-static GtkWidget *get_results_window(struct gui *ui)
+static GtkWidget *get_results_window(struct gui_entry *ge)
{
GtkWidget *win, *notebook;
- if (ui->results_window)
- return ui->results_notebook;
+ if (ge->results_window)
+ return ge->results_notebook;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win), "Results");
- g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ui);
- g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ui);
+ gtk_window_set_default_size(GTK_WINDOW(win), 1024, 768);
+ g_signal_connect(win, "delete-event", G_CALLBACK(results_window_delete), ge);
+ g_signal_connect(win, "destroy", G_CALLBACK(results_window_delete), ge);
notebook = gtk_notebook_new();
+ gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), 1);
+ gtk_notebook_popup_enable(GTK_NOTEBOOK(notebook));
gtk_container_add(GTK_CONTAINER(win), notebook);
- ui->results_window = win;
- ui->results_notebook = notebook;
- return ui->results_notebook;
+ ge->results_window = win;
+ ge->results_notebook = notebook;
+ return ge->results_notebook;
}
static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
struct group_run_stats *rs)
{
- GtkWidget *res_win, *box, *vbox, *entry;
+ GtkWidget *res_win, *box, *vbox, *entry, *scroll;
struct gfio_client *gc = client->client_data;
gdk_threads_enter();
- res_win = get_results_window(gc->ui);
+ res_win = get_results_window(gc->ge);
+
+ scroll = gtk_scrolled_window_new(NULL, NULL);
+ gtk_container_set_border_width(GTK_CONTAINER(scroll), 5);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
vbox = gtk_vbox_new(FALSE, 3);
- box = gtk_hbox_new(TRUE, 3);
- gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
+ box = gtk_hbox_new(FALSE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 5);
+
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scroll), vbox);
- gtk_notebook_append_page(GTK_NOTEBOOK(res_win), vbox, gtk_label_new(ts->name));
+ gtk_notebook_append_page(GTK_NOTEBOOK(res_win), scroll, gtk_label_new(ts->name));
gc->results_widget = vbox;
entry_set_int_value(entry, ts->groupid);
entry = new_info_entry_in_frame(box, "Jobs");
entry_set_int_value(entry, ts->members);
- entry = new_info_entry_in_frame(box, "Error");
+ gc->err_entry = entry = new_info_entry_in_frame(box, "Error");
entry_set_int_value(entry, ts->error);
entry = new_info_entry_in_frame(box, "PID");
entry_set_int_value(entry, ts->pid);
gfio_show_cpu_usage(vbox, ts);
gfio_show_io_depths(vbox, ts);
- gtk_widget_show_all(gc->ui->results_window);
+ gtk_widget_show_all(gc->ge->results_window);
gdk_threads_leave();
}
static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
{
struct cmd_text_pdu *p = (struct cmd_text_pdu *) cmd->payload;
- struct gfio_client *gc = client->client_data;
+ struct gui *ui = &main_ui;
GtkTreeIter iter;
struct tm *tm;
time_t sec;
gdk_threads_enter();
- gtk_list_store_append(gc->ui->log_model, &iter);
- gtk_list_store_set(gc->ui->log_model, &iter, 0, timebuf, -1);
- gtk_list_store_set(gc->ui->log_model, &iter, 1, client->hostname, -1);
- gtk_list_store_set(gc->ui->log_model, &iter, 2, p->level, -1);
- gtk_list_store_set(gc->ui->log_model, &iter, 3, p->buf, -1);
+ gtk_list_store_append(ui->log_model, &iter);
+ gtk_list_store_set(ui->log_model, &iter, 0, timebuf, -1);
+ gtk_list_store_set(ui->log_model, &iter, 1, client->hostname, -1);
+ gtk_list_store_set(ui->log_model, &iter, 2, p->level, -1);
+ gtk_list_store_set(ui->log_model, &iter, 3, p->buf, -1);
+
+ if (p->level == FIO_LOG_ERR)
+ view_log(NULL, (gpointer) ui);
gdk_threads_leave();
}
struct cmd_du_pdu *p = (struct cmd_du_pdu *) cmd->payload;
struct gfio_client *gc = client->client_data;
GtkWidget *box, *frame, *entry, *vbox;
+ double util;
+ char tmp[16];
gdk_threads_enter();
- if (!gc->results_widget) {
- printf("no results!\n");
+ if (!gc->results_widget)
goto out;
- }
if (!gc->disk_util_frame) {
gc->disk_util_frame = gtk_frame_new("Disk utilization");
entry = new_info_entry_in_frame(vbox, "Time in queue");
entry_set_int_value(entry, p->dus.time_in_queue);
+ util = 0.0;
+ if (p->dus.msec)
+ util = (double) 100 * p->dus.io_ticks / (double) p->dus.msec;
+ if (util > 100.0)
+ util = 100.0;
+
+ sprintf(tmp, "%3.2f%%", util);
+ entry = new_info_entry_in_frame(vbox, "Disk utilization");
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+
gtk_widget_show_all(gc->results_widget);
out:
gdk_threads_leave();
static void gfio_group_stats_op(struct fio_client *client,
struct fio_net_cmd *cmd)
{
- gdk_threads_enter();
- printf("gfio_group_stats_op called\n");
- fio_client_ops.group_stats(client, cmd);
- gdk_threads_leave();
+ /* We're ignoring group stats for now */
}
-static void gfio_update_eta(struct jobs_eta *je)
+static gint on_config_drawing_area(GtkWidget *w, GdkEventConfigure *event,
+ gpointer data)
{
+ struct gfio_graphs *g = data;
+
+ graph_set_size(g->iops_graph, w->allocation.width / 2.0, w->allocation.height);
+ graph_set_position(g->iops_graph, w->allocation.width / 2.0, 0.0);
+ graph_set_size(g->bandwidth_graph, w->allocation.width / 2.0, w->allocation.height);
+ graph_set_position(g->bandwidth_graph, 0, 0);
+ return TRUE;
+}
+
+static void draw_graph(struct graph *g, cairo_t *cr)
+{
+ line_graph_draw(g, cr);
+ cairo_stroke(cr);
+}
+
+static int on_expose_drawing_area(GtkWidget *w, GdkEvent *event, gpointer p)
+{
+ struct gfio_graphs *g = p;
+ cairo_t *cr;
+
+ cr = gdk_cairo_create(w->window);
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ draw_graph(g->iops_graph, cr);
+ draw_graph(g->bandwidth_graph, cr);
+ cairo_destroy(cr);
+
+ return FALSE;
+}
+
+/*
+ * Client specific ETA
+ */
+static void gfio_update_client_eta(struct fio_client *client, struct jobs_eta *je)
+{
+ struct gfio_client *gc = client->client_data;
+ struct gui_entry *ge = gc->ge;
static int eta_good;
char eta_str[128];
char output[256];
}
sprintf(tmp, "%u", je->nr_running);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.jobs), tmp);
sprintf(tmp, "%u", je->files_open);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.files), tmp);
+
+#if 0
+ if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
+ if (je->m_rate || je->t_rate) {
+ char *tr, *mr;
+
+ mr = num2str(je->m_rate, 4, 0, i2p);
+ tr = num2str(je->t_rate, 4, 0, i2p);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta);
+ p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
+ free(tr);
+ free(mr);
+ } else if (je->m_iops || je->t_iops)
+ p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
+
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cr_iops), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.cw_iops), "---");
+#endif
+
+ if (je->eta_sec != INT_MAX && je->nr_running) {
+ char *iops_str[2];
+ char *rate_str[2];
+
+ if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running)
+ strcpy(output, "-.-% done");
+ else {
+ eta_good = 1;
+ perc *= 100.0;
+ sprintf(output, "%3.1f%% done", perc);
+ }
+
+ rate_str[0] = num2str(je->rate[0], 5, 10, i2p);
+ rate_str[1] = num2str(je->rate[1], 5, 10, i2p);
+
+ iops_str[0] = num2str(je->iops[0], 4, 1, 0);
+ iops_str[1] = num2str(je->iops[1], 4, 1, 0);
+
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_bw), rate_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.read_iops), iops_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_bw), rate_str[1]);
+ gtk_entry_set_text(GTK_ENTRY(ge->eta.write_iops), iops_str[1]);
+
+ graph_add_xy_data(ge->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
+ graph_add_xy_data(ge->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
+ graph_add_xy_data(ge->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
+ graph_add_xy_data(ge->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
+
+ free(rate_str[0]);
+ free(rate_str[1]);
+ free(iops_str[0]);
+ free(iops_str[1]);
+ }
+
+ if (eta_str[0]) {
+ char *dst = output + strlen(output);
+
+ sprintf(dst, " - %s", eta_str);
+ }
+
+ gfio_update_thread_status(ge, output, perc);
+ gdk_threads_leave();
+}
+
+/*
+ * Update ETA in main window for all clients
+ */
+static void gfio_update_all_eta(struct jobs_eta *je)
+{
+ struct gui *ui = &main_ui;
+ static int eta_good;
+ char eta_str[128];
+ char output[256];
+ double perc = 0.0;
+ int i2p = 0;
+
+ gdk_threads_enter();
+
+ eta_str[0] = '\0';
+ output[0] = '\0';
+
+ if (je->eta_sec != INT_MAX && je->elapsed_sec) {
+ perc = (double) je->elapsed_sec / (double) (je->elapsed_sec + je->eta_sec);
+ eta_to_str(eta_str, je->eta_sec);
+ }
#if 0
if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) {
mr = num2str(je->m_rate, 4, 0, i2p);
tr = num2str(je->t_rate, 4, 0, i2p);
- gtk_entry_set_text(GTK_ENTRY(ui.eta);
+ gtk_entry_set_text(GTK_ENTRY(ui->eta);
p += sprintf(p, ", CR=%s/%s KB/s", tr, mr);
free(tr);
free(mr);
} else if (je->m_iops || je->t_iops)
p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_bw), "---");
- gtk_entry_set_text(GTK_ENTRY(ui.eta.cr_iops), "---");
- gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_bw), "---");
- gtk_entry_set_text(GTK_ENTRY(ui.eta.cw_iops), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.cr_iops), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_bw), "---");
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.cw_iops), "---");
#endif
+ entry_set_int_value(ui->eta.jobs, je->nr_running);
+
if (je->eta_sec != INT_MAX && je->nr_running) {
char *iops_str[2];
char *rate_str[2];
iops_str[0] = num2str(je->iops[0], 4, 1, 0);
iops_str[1] = num2str(je->iops[1], 4, 1, 0);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.read_bw), rate_str[0]);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.read_iops), iops_str[0]);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.write_bw), rate_str[1]);
- gtk_entry_set_text(GTK_ENTRY(ui.eta.write_iops), iops_str[1]);
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.read_bw), rate_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.read_iops), iops_str[0]);
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.write_bw), rate_str[1]);
+ gtk_entry_set_text(GTK_ENTRY(ui->eta.write_iops), iops_str[1]);
+
+ graph_add_xy_data(ui->graphs.iops_graph, "Read IOPS", je->elapsed_sec, je->iops[0]);
+ graph_add_xy_data(ui->graphs.iops_graph, "Write IOPS", je->elapsed_sec, je->iops[1]);
+ graph_add_xy_data(ui->graphs.bandwidth_graph, "Read Bandwidth", je->elapsed_sec, je->rate[0]);
+ graph_add_xy_data(ui->graphs.bandwidth_graph, "Write Bandwidth", je->elapsed_sec, je->rate[1]);
free(rate_str[0]);
free(rate_str[1]);
sprintf(dst, " - %s", eta_str);
}
- gfio_update_thread_status(output, perc);
+ gfio_update_thread_status_all(output, perc);
gdk_threads_leave();
}
{
struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
struct gfio_client *gc = client->client_data;
- struct gui *ui = gc->ui;
+ struct gui_entry *ge = gc->ge;
const char *os, *arch;
char buf[64];
gdk_threads_enter();
- gtk_label_set_text(GTK_LABEL(ui->probe.hostname), (char *) probe->hostname);
- gtk_label_set_text(GTK_LABEL(ui->probe.os), os);
- gtk_label_set_text(GTK_LABEL(ui->probe.arch), arch);
+ gtk_label_set_text(GTK_LABEL(ge->probe.hostname), (char *) probe->hostname);
+ gtk_label_set_text(GTK_LABEL(ge->probe.os), os);
+ gtk_label_set_text(GTK_LABEL(ge->probe.arch), arch);
sprintf(buf, "%u.%u.%u", probe->fio_major, probe->fio_minor, probe->fio_patch);
- gtk_label_set_text(GTK_LABEL(ui->probe.fio_ver), buf);
+ gtk_label_set_text(GTK_LABEL(ge->probe.fio_ver), buf);
- gfio_set_connected(ui, 1);
+ gfio_set_connected(ge, 1);
gdk_threads_leave();
}
-static void gfio_update_thread_status(char *status_message, double perc)
+static void gfio_update_thread_status(struct gui_entry *ge,
+ char *status_message, double perc)
+{
+ static char message[100];
+ const char *m = message;
+
+ strncpy(message, status_message, sizeof(message) - 1);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), m);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), perc / 100.0);
+ gtk_widget_queue_draw(main_ui.window);
+}
+
+static void gfio_update_thread_status_all(char *status_message, double perc)
{
+ struct gui *ui = &main_ui;
static char message[100];
const char *m = message;
strncpy(message, status_message, sizeof(message) - 1);
- gtk_progress_bar_set_text(
- GTK_PROGRESS_BAR(ui.thread_status_pb), m);
- gtk_progress_bar_set_fraction(
- GTK_PROGRESS_BAR(ui.thread_status_pb), perc / 100.0);
- gtk_widget_queue_draw(ui.window);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), m);
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ui->thread_status_pb), perc / 100.0);
+ gtk_widget_queue_draw(ui->window);
}
static void gfio_quit_op(struct fio_client *client)
struct gfio_client *gc = client->client_data;
gdk_threads_enter();
- gfio_set_connected(gc->ui, 0);
+ gfio_set_connected(gc->ge, 0);
gdk_threads_leave();
}
{
struct cmd_add_job_pdu *p = (struct cmd_add_job_pdu *) cmd->payload;
struct gfio_client *gc = client->client_data;
- struct gui *ui = gc->ui;
+ struct thread_options *o = &gc->o;
+ struct gui_entry *ge = gc->ge;
char tmp[8];
- int i;
- p->iodepth = le32_to_cpu(p->iodepth);
- p->rw = le32_to_cpu(p->rw);
+ convert_thread_options_to_cpu(o, &p->top);
- for (i = 0; i < 2; i++) {
- p->min_bs[i] = le32_to_cpu(p->min_bs[i]);
- p->max_bs[i] = le32_to_cpu(p->max_bs[i]);
- }
+ gdk_threads_enter();
- p->numjobs = le32_to_cpu(p->numjobs);
- p->group_reporting = le32_to_cpu(p->group_reporting);
+ gtk_label_set_text(GTK_LABEL(ge->page_label), (gchar *) o->name);
- gdk_threads_enter();
+ gtk_combo_box_append_text(GTK_COMBO_BOX(ge->eta.names), (gchar *) o->name);
+ gtk_combo_box_set_active(GTK_COMBO_BOX(ge->eta.names), 0);
- gtk_entry_set_text(GTK_ENTRY(ui->eta.name), (gchar *) p->jobname);
- gtk_entry_set_text(GTK_ENTRY(ui->eta.iotype), ddir_str(p->rw));
- gtk_entry_set_text(GTK_ENTRY(ui->eta.ioengine), (gchar *) p->ioengine);
+ multitext_add_entry(&ge->eta.iotype, ddir_str(o->td_ddir));
+ multitext_add_entry(&ge->eta.ioengine, (const char *) o->ioengine);
- sprintf(tmp, "%u", p->iodepth);
- gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp);
+ sprintf(tmp, "%u", o->iodepth);
+ multitext_add_entry(&ge->eta.iodepth, tmp);
+
+ multitext_set_entry(&ge->eta.iotype, 0);
+ multitext_set_entry(&ge->eta.ioengine, 0);
+ multitext_set_entry(&ge->eta.iodepth, 0);
+
+ gc->job_added++;
gdk_threads_leave();
}
gdk_threads_enter();
- gfio_set_connected(gc->ui, 0);
- clear_ui_info(gc->ui);
+ gfio_set_connected(gc->ge, 0);
+ clear_ge_ui_info(gc->ge);
sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
dialog = gtk_dialog_new_with_buttons("Timed out!",
- GTK_WINDOW(gc->ui->window),
+ GTK_WINDOW(main_ui.window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_OK, NULL);
- content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+ /* gtk_dialog_get_content_area() is 2.14 and newer */
+ content = GTK_DIALOG(dialog)->vbox;
+
label = gtk_label_new((const gchar *) buf);
gtk_container_add(GTK_CONTAINER(content), label);
gtk_widget_show_all(dialog);
gdk_threads_leave();
}
+static void gfio_client_stop(struct fio_client *client, struct fio_net_cmd *cmd)
+{
+ struct gfio_client *gc = client->client_data;
+
+ gdk_threads_enter();
+
+ gfio_set_connected(gc->ge, 0);
+
+ if (gc->err_entry)
+ entry_set_int_value(gc->err_entry, client->error);
+
+ gdk_threads_leave();
+}
+
struct client_ops gfio_client_ops = {
.text_op = gfio_text_op,
.disk_util = gfio_disk_util_op,
.thread_status = gfio_thread_status_op,
.group_stats = gfio_group_stats_op,
- .eta = gfio_update_eta,
+ .jobs_eta = gfio_update_client_eta,
+ .eta = gfio_update_all_eta,
.probe = gfio_probe_op,
.quit = gfio_quit_op,
.add_job = gfio_add_job_op,
.timed_out = gfio_client_timed_out,
+ .stop = gfio_client_stop,
+ .eta_msec = FIO_CLIENT_DEF_ETA_MSEC,
.stay_connected = 1,
};
static void *job_thread(void *arg)
{
+ struct gui *ui = arg;
+
+ ui->handler_running = 1;
fio_handle_clients(&gfio_client_ops);
+ ui->handler_running = 0;
return NULL;
}
-static int send_job_files(struct gui *ui)
+static int send_job_files(struct gui_entry *ge)
{
+ struct gfio_client *gc = ge->client;
int i, ret = 0;
- for (i = 0; i < ui->nr_job_files; i++) {
- ret = fio_clients_send_ini(ui->job_files[i]);
- if (ret)
+ for (i = 0; i < ge->nr_job_files; i++) {
+ ret = fio_client_send_ini(gc->client, ge->job_files[i]);
+ if (ret < 0) {
+ GError *error;
+
+ error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send file %s: %s\n", ge->job_files[i], strerror(-ret));
+ report_error(error);
+ g_error_free(error);
+ break;
+ } else if (ret)
break;
- free(ui->job_files[i]);
- ui->job_files[i] = NULL;
+ free(ge->job_files[i]);
+ ge->job_files[i] = NULL;
}
- while (i < ui->nr_job_files) {
- free(ui->job_files[i]);
- ui->job_files[i] = NULL;
+ while (i < ge->nr_job_files) {
+ free(ge->job_files[i]);
+ ge->job_files[i] = NULL;
i++;
}
return ret;
}
-static void start_job_thread(struct gui *ui)
+static void *server_thread(void *arg)
{
- if (send_job_files(ui)) {
- printf("Yeah, I didn't really like those options too much.\n");
- gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 1);
- return;
+ is_backend = 1;
+ gfio_server_running = 1;
+ fio_start_server(NULL);
+ gfio_server_running = 0;
+ return NULL;
+}
+
+static void gfio_start_server(void)
+{
+ struct gui *ui = &main_ui;
+
+ if (!gfio_server_running) {
+ gfio_server_running = 1;
+ pthread_create(&ui->server_t, NULL, server_thread, NULL);
+ pthread_detach(ui->server_t);
}
}
static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
gpointer data)
{
- struct gui *ui = data;
+ struct gui_entry *ge = data;
+ struct gfio_client *gc = ge->client;
- gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
- start_job_thread(ui);
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 0);
+ fio_start_client(gc->client);
}
static void file_open(GtkWidget *w, gpointer data);
static void connect_clicked(GtkWidget *widget, gpointer data)
{
- struct gui *ui = data;
+ struct gui_entry *ge = data;
+ struct gfio_client *gc = ge->client;
- if (!ui->connected) {
- if (!ui->nr_job_files)
+ if (!ge->connected) {
+ int ret;
+
+ if (!ge->nr_job_files)
file_open(widget, data);
- gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No jobs running");
- if (!fio_clients_connect()) {
- pthread_create(&ui->t, NULL, job_thread, NULL);
- gtk_widget_set_sensitive(ui->button[CONNECT_BUTTON], 0);
+ if (!ge->nr_job_files)
+ return;
+
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No jobs running");
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
+ ret = fio_client_connect(gc->client);
+ if (!ret) {
+ if (!ge->ui->handler_running)
+ pthread_create(&ge->ui->t, NULL, job_thread, ge->ui);
+ gtk_widget_set_sensitive(ge->button[CONNECT_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 1);
+ } else {
+ GError *error;
+
+ error = g_error_new(g_quark_from_string("fio"), 1, "Failed to connect to %s: %s\n", ge->client->client->hostname, strerror(-ret));
+ report_error(error);
+ g_error_free(error);
}
} else {
- fio_clients_terminate();
- gfio_set_connected(ui, 0);
- clear_ui_info(ui);
+ fio_client_terminate(gc->client);
+ gfio_set_connected(ge, 0);
+ clear_ge_ui_info(ge);
}
}
-static void add_button(struct gui *ui, int i, GtkWidget *buttonbox,
- struct button_spec *buttonspec)
+static void send_clicked(GtkWidget *widget, gpointer data)
+{
+ struct gui_entry *ge = data;
+
+ if (send_job_files(ge)) {
+ GError *error;
+
+ error = g_error_new(g_quark_from_string("fio"), 1, "Failed to send one or more job files for client %s", ge->client->client->hostname);
+ report_error(error);
+ g_error_free(error);
+
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
+ }
+
+ gtk_widget_set_sensitive(ge->button[SEND_BUTTON], 0);
+ gtk_widget_set_sensitive(ge->button[START_JOB_BUTTON], 1);
+}
+
+static GtkWidget *add_button(GtkWidget *buttonbox,
+ struct button_spec *buttonspec, gpointer data)
{
- ui->button[i] = gtk_button_new_with_label(buttonspec->buttontext);
- g_signal_connect(ui->button[i], "clicked", G_CALLBACK (buttonspec->f), ui);
- gtk_box_pack_start(GTK_BOX (ui->buttonbox), ui->button[i], FALSE, FALSE, 3);
- gtk_widget_set_tooltip_text(ui->button[i], buttonspeclist[i].tooltiptext);
- gtk_widget_set_sensitive(ui->button[i], !buttonspec->start_insensitive);
+ GtkWidget *button = gtk_button_new_with_label(buttonspec->buttontext);
+
+ g_signal_connect(button, "clicked", G_CALLBACK(buttonspec->f), data);
+ gtk_box_pack_start(GTK_BOX(buttonbox), button, FALSE, FALSE, 3);
+ gtk_widget_set_tooltip_text(button, buttonspec->tooltiptext);
+ gtk_widget_set_sensitive(button, !buttonspec->start_insensitive);
+
+ return button;
}
-static void add_buttons(struct gui *ui,
- struct button_spec *buttonlist,
- int nbuttons)
+static void add_buttons(struct gui_entry *ge, struct button_spec *buttonlist,
+ int nbuttons)
{
int i;
for (i = 0; i < nbuttons; i++)
- add_button(ui, i, ui->buttonbox, &buttonlist[i]);
+ ge->button[i] = add_button(ge->buttonbox, &buttonlist[i], ge);
}
static void on_info_bar_response(GtkWidget *widget, gint response,
gpointer data)
{
+ struct gui *ui = &main_ui;
+
if (response == GTK_RESPONSE_OK) {
gtk_widget_destroy(widget);
- ui.error_info_bar = NULL;
+ ui->error_info_bar = NULL;
}
}
void report_error(GError *error)
{
- if (ui.error_info_bar == NULL) {
- ui.error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
+ struct gui *ui = &main_ui;
+
+ if (ui->error_info_bar == NULL) {
+ ui->error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
- g_signal_connect(ui.error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
- gtk_info_bar_set_message_type(GTK_INFO_BAR(ui.error_info_bar),
+ g_signal_connect(ui->error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
+ gtk_info_bar_set_message_type(GTK_INFO_BAR(ui->error_info_bar),
GTK_MESSAGE_ERROR);
- ui.error_label = gtk_label_new(error->message);
- GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui.error_info_bar));
- gtk_container_add(GTK_CONTAINER(container), ui.error_label);
+ ui->error_label = gtk_label_new(error->message);
+ GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(ui->error_info_bar));
+ gtk_container_add(GTK_CONTAINER(container), ui->error_label);
- gtk_box_pack_start(GTK_BOX(ui.vbox), ui.error_info_bar, FALSE, FALSE, 0);
- gtk_widget_show_all(ui.vbox);
+ gtk_box_pack_start(GTK_BOX(ui->vbox), ui->error_info_bar, FALSE, FALSE, 0);
+ gtk_widget_show_all(ui->vbox);
} else {
char buffer[256];
snprintf(buffer, sizeof(buffer), "Failed to open file.");
- gtk_label_set(GTK_LABEL(ui.error_label), buffer);
+ gtk_label_set(GTK_LABEL(ui->error_label), buffer);
+ }
+}
+
+struct connection_widgets
+{
+ GtkWidget *hentry;
+ GtkWidget *combo;
+ GtkWidget *button;
+};
+
+static void hostname_cb(GtkEntry *entry, gpointer data)
+{
+ struct connection_widgets *cw = data;
+ int uses_net = 0, is_localhost = 0;
+ const gchar *text;
+ gchar *ctext;
+
+ /*
+ * Check whether to display the 'auto start backend' box
+ * or not. Show it if we are a localhost and using network,
+ * or using a socket.
+ */
+ ctext = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw->combo));
+ if (!ctext || !strncmp(ctext, "IPv4", 4) || !strncmp(ctext, "IPv6", 4))
+ uses_net = 1;
+ g_free(ctext);
+
+ if (uses_net) {
+ text = gtk_entry_get_text(GTK_ENTRY(cw->hentry));
+ if (!strcmp(text, "127.0.0.1") || !strcmp(text, "localhost") ||
+ !strcmp(text, "::1") || !strcmp(text, "ip6-localhost") ||
+ !strcmp(text, "ip6-loopback"))
+ is_localhost = 1;
+ }
+
+ if (!uses_net || is_localhost) {
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 1);
+ gtk_widget_set_sensitive(cw->button, 1);
+ } else {
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw->button), 0);
+ gtk_widget_set_sensitive(cw->button, 0);
}
}
static int get_connection_details(char **host, int *port, int *type,
int *server_start)
{
- GtkWidget *dialog, *box, *vbox, *hentry, *hbox, *frame, *pentry, *combo;
- GtkWidget *button;
+ GtkWidget *dialog, *box, *vbox, *hbox, *frame, *pentry;
+ struct connection_widgets cw;
char *typeentry;
dialog = gtk_dialog_new_with_buttons("Connection details",
- GTK_WINDOW(ui.window),
+ GTK_WINDOW(main_ui.window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, NULL);
frame = gtk_frame_new("Hostname / socket name");
- vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+ /* gtk_dialog_get_content_area() is 2.14 and newer */
+ vbox = GTK_DIALOG(dialog)->vbox;
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
box = gtk_vbox_new(FALSE, 6);
hbox = gtk_hbox_new(TRUE, 10);
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
- hentry = gtk_entry_new();
- gtk_entry_set_text(GTK_ENTRY(hentry), "localhost");
- gtk_box_pack_start(GTK_BOX(hbox), hentry, TRUE, TRUE, 0);
+ cw.hentry = gtk_entry_new();
+ gtk_entry_set_text(GTK_ENTRY(cw.hentry), "localhost");
+ gtk_box_pack_start(GTK_BOX(hbox), cw.hentry, TRUE, TRUE, 0);
frame = gtk_frame_new("Port");
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
- combo = gtk_combo_box_new_text();
- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "IPv4");
- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "IPv6");
- gtk_combo_box_append_text(GTK_COMBO_BOX(combo), "local socket");
- gtk_combo_box_set_active(GTK_COMBO_BOX(combo), 0);
+ cw.combo = gtk_combo_box_new_text();
+ gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv4");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "IPv6");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(cw.combo), "local socket");
+ gtk_combo_box_set_active(GTK_COMBO_BOX(cw.combo), 0);
- gtk_container_add(GTK_CONTAINER(hbox), combo);
+ gtk_container_add(GTK_CONTAINER(hbox), cw.combo);
frame = gtk_frame_new("Options");
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
hbox = gtk_hbox_new(TRUE, 4);
gtk_box_pack_start(GTK_BOX(box), hbox, FALSE, FALSE, 0);
- button = gtk_check_button_new_with_label("Auto-spawn fio backend");
- gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), 1);
- 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.");
- gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 6);
+ cw.button = gtk_check_button_new_with_label("Auto-spawn fio backend");
+ gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(cw.button), 1);
+ 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.");
+ gtk_box_pack_start(GTK_BOX(hbox), cw.button, FALSE, FALSE, 6);
+
+ /*
+ * Connect edit signal, so we can show/not-show the auto start button
+ */
+ g_signal_connect(GTK_OBJECT(cw.hentry), "changed", G_CALLBACK(hostname_cb), &cw);
+ g_signal_connect(GTK_OBJECT(cw.combo), "changed", G_CALLBACK(hostname_cb), &cw);
gtk_widget_show_all(dialog);
return 1;
}
- *host = strdup(gtk_entry_get_text(GTK_ENTRY(hentry)));
+ *host = strdup(gtk_entry_get_text(GTK_ENTRY(cw.hentry)));
*port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pentry));
- typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo));
+ typeentry = gtk_combo_box_get_active_text(GTK_COMBO_BOX(cw.combo));
if (!typeentry || !strncmp(typeentry, "IPv4", 4))
*type = Fio_client_ipv4;
else if (!strncmp(typeentry, "IPv6", 4))
*type = Fio_client_socket;
g_free(typeentry);
- *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
+ *server_start = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cw.button));
gtk_widget_destroy(dialog);
return 0;
}
-static void gfio_client_added(struct gui *ui, struct fio_client *client)
+static void gfio_client_added(struct gui_entry *ge, struct fio_client *client)
{
struct gfio_client *gc;
gc = malloc(sizeof(*gc));
memset(gc, 0, sizeof(*gc));
- gc->ui = ui;
+ gc->ge = ge;
+ gc->client = fio_get_client(client);
+
+ ge->client = gc;
client->client_data = gc;
}
+static GtkWidget *new_client_page(struct gui_entry *ge);
+
+static struct gui_entry *alloc_new_gui_entry(struct gui *ui)
+{
+ struct gui_entry *ge;
+
+ ge = malloc(sizeof(*ge));
+ memset(ge, 0, sizeof(*ge));
+ INIT_FLIST_HEAD(&ge->list);
+ flist_add_tail(&ge->list, &ui->list);
+ ge->ui = ui;
+ return ge;
+}
+
+/*
+ * FIXME: need more handling here
+ */
+static void ge_destroy(GtkWidget *w, gpointer data)
+{
+ struct gui_entry *ge = data;
+ struct gfio_client *gc = ge->client;
+
+ if (gc->client)
+ fio_put_client(gc->client);
+
+ flist_del(&ge->list);
+ free(ge);
+}
+
+static struct gui_entry *get_new_ge_with_tab(const char *name)
+{
+ struct gui_entry *ge;
+
+ ge = alloc_new_gui_entry(&main_ui);
+
+ ge->vbox = new_client_page(ge);
+ g_signal_connect(ge->vbox, "destroy", G_CALLBACK(ge_destroy), ge);
+
+ ge->page_label = gtk_label_new(name);
+ ge->page_num = gtk_notebook_append_page(GTK_NOTEBOOK(main_ui.notebook), ge->vbox, ge->page_label);
+
+ gtk_widget_show_all(main_ui.window);
+ return ge;
+}
+
+static void file_new(GtkWidget *w, gpointer data)
+{
+ get_new_ge_with_tab("Untitled");
+}
+
+/*
+ * Return the 'ge' corresponding to the tab. If the active tab is the
+ * main tab, open a new tab.
+ */
+static struct gui_entry *get_ge_from_page(unsigned int cur_page)
+{
+ struct flist_head *entry;
+ struct gui_entry *ge;
+
+ if (!cur_page)
+ return get_new_ge_with_tab("Untitled");
+
+ flist_for_each(entry, &main_ui.list) {
+ ge = flist_entry(entry, struct gui_entry, list);
+ if (ge->page_num == cur_page)
+ return ge;
+ }
+
+ return NULL;
+}
+
static void file_open(GtkWidget *w, gpointer data)
{
+ struct gui *ui = data;
GtkWidget *dialog;
GSList *filenames, *fn_glist;
GtkFileFilter *filter;
char *host;
int port, type, server_start;
+ struct gui_entry *ge;
+ gint cur_page;
+
+ /*
+ * Creates new tab if current tab is the main window, or the
+ * current tab already has a client.
+ */
+ cur_page = gtk_notebook_get_current_page(GTK_NOTEBOOK(ui->notebook));
+ ge = get_ge_from_page(cur_page);
+ if (ge->client)
+ ge = get_new_ge_with_tab("Untitled");
+
+ gtk_notebook_set_current_page(GTK_NOTEBOOK(ui->notebook), ge->page_num);
dialog = gtk_file_chooser_dialog_new("Open File",
- GTK_WINDOW(ui.window),
+ GTK_WINDOW(ui->window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*.fio");
gtk_file_filter_add_pattern(filter, "*.job");
+ gtk_file_filter_add_pattern(filter, "*.ini");
gtk_file_filter_add_mime_type(filter, "text/fio");
gtk_file_filter_set_name(filter, "Fio job file");
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
while (filenames != NULL) {
struct fio_client *client;
- ui.job_files = realloc(ui.job_files, (ui.nr_job_files + 1) * sizeof(char *));
- ui.job_files[ui.nr_job_files] = strdup(filenames->data);
- ui.nr_job_files++;
+ ge->job_files = realloc(ge->job_files, (ge->nr_job_files + 1) * sizeof(char *));
+ ge->job_files[ge->nr_job_files] = strdup(filenames->data);
+ ge->nr_job_files++;
client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
if (!client) {
report_error(error);
g_error_free(error);
}
- gfio_client_added(&ui, client);
+ gfio_client_added(ge, client);
g_free(filenames->data);
filenames = g_slist_next(filenames);
}
free(host);
+
+ if (server_start)
+ gfio_start_server();
err:
g_slist_free(fn_glist);
}
static void file_save(GtkWidget *w, gpointer data)
{
+ struct gui *ui = data;
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save File",
- GTK_WINDOW(ui.window),
+ GTK_WINDOW(ui->window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
gtk_widget_show_all(win);
}
+static void __update_graph_limits(struct gfio_graphs *g)
+{
+ line_graph_set_data_count_limit(g->iops_graph, gfio_graph_limit);
+ line_graph_set_data_count_limit(g->bandwidth_graph, gfio_graph_limit);
+}
+
+static void update_graph_limits(void)
+{
+ struct flist_head *entry;
+ struct gui_entry *ge;
+
+ __update_graph_limits(&main_ui.graphs);
+
+ flist_for_each(entry, &main_ui.list) {
+ ge = flist_entry(entry, struct gui_entry, list);
+ __update_graph_limits(&ge->graphs);
+ }
+}
+
static void preferences(GtkWidget *w, gpointer data)
{
- GtkWidget *dialog, *frame, *box, **buttons;
+ GtkWidget *dialog, *frame, *box, **buttons, *vbox, *font;
+ GtkWidget *hbox, *spin, *entry, *spin_int;
int i;
dialog = gtk_dialog_new_with_buttons("Preferences",
- GTK_WINDOW(ui.window),
+ GTK_WINDOW(main_ui.window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
+ frame = gtk_frame_new("Graphing");
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
+ vbox = gtk_vbox_new(FALSE, 6);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+
+ hbox = gtk_hbox_new(FALSE, 5);
+ gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
+ entry = gtk_label_new("Font face to use for graph labels");
+ gtk_box_pack_start(GTK_BOX(hbox), entry, TRUE, TRUE, 5);
+
+ font = gtk_font_button_new();
+ gtk_box_pack_start(GTK_BOX(hbox), font, FALSE, FALSE, 5);
+
+ box = gtk_vbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 5);
+ gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
+ entry = gtk_label_new("Maximum number of data points in graph (seconds)");
+ gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
+
+ spin = create_spinbutton(hbox, 10, 1000000, gfio_graph_limit);
+
+ box = gtk_vbox_new(FALSE, 6);
+ gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 5);
+ gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 5);
+ entry = gtk_label_new("Client ETA request interval (msec)");
+ gtk_box_pack_start(GTK_BOX(hbox), entry, FALSE, FALSE, 5);
+
+ spin_int = create_spinbutton(hbox, 100, 100000, gfio_client_ops.eta_msec);
frame = gtk_frame_new("Debug logging");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
+ vbox = gtk_vbox_new(FALSE, 6);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+
box = gtk_hbox_new(FALSE, 6);
- gtk_container_add(GTK_CONTAINER(frame), box);
+ gtk_container_add(GTK_CONTAINER(vbox), box);
buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
for (i = 0; i < FD_DEBUG_MAX; i++) {
+ if (i == 7) {
+ box = gtk_hbox_new(FALSE, 6);
+ gtk_container_add(GTK_CONTAINER(vbox), box);
+ }
+
+
buttons[i] = gtk_check_button_new_with_label(debug_levels[i].name);
gtk_widget_set_tooltip_text(buttons[i], debug_levels[i].help);
gtk_box_pack_start(GTK_BOX(box), buttons[i], FALSE, FALSE, 6);
fio_debug |= (1UL << i);
}
+ gfio_graph_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
+ gfio_graph_limit = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
+ update_graph_limits();
+ gfio_client_ops.eta_msec = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_int));
+
gtk_widget_destroy(dialog);
}
static void about_dialog(GtkWidget *w, gpointer data)
{
+ const char *authors[] = {
+ "Jens Axboe <axboe@kernel.dk>",
+ "Stephen Carmeron <stephenmcameron@gmail.com>",
+ NULL
+ };
+ const char *license[] = {
+ "Fio is free software; you can redistribute it and/or modify "
+ "it under the terms of the GNU General Public License as published by "
+ "the Free Software Foundation; either version 2 of the License, or "
+ "(at your option) any later version.\n",
+ "Fio is distributed in the hope that it will be useful, "
+ "but WITHOUT ANY WARRANTY; without even the implied warranty of "
+ "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
+ "GNU General Public License for more details.\n",
+ "You should have received a copy of the GNU General Public License "
+ "along with Fio; if not, write to the Free Software Foundation, Inc., "
+ "51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
+ };
+ char *license_trans;
+
+ license_trans = g_strconcat(license[0], "\n", license[1], "\n",
+ license[2], "\n", NULL);
+
gtk_show_about_dialog(NULL,
"program-name", "gfio",
"comments", "Gtk2 UI for fio",
- "license", "GPLv2",
+ "license", license_trans,
+ "website", "http://git.kernel.dk/?p=fio.git;a=summary",
+ "authors", authors,
"version", fio_version_string,
- "copyright", "Jens Axboe <axboe@kernel.dk> 2012",
+ "copyright", "© 2012 Jens Axboe <axboe@kernel.dk>",
"logo-icon-name", "fio",
/* Must be last: */
- NULL, NULL,
+ "wrap-license", TRUE,
NULL);
+
+ g_free(license_trans);
}
static GtkActionEntry menu_items[] = {
{ "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
{ "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
{ "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
+ { "NewFile", GTK_STOCK_NEW, "New", "<Control>N", NULL, G_CALLBACK(file_new) },
{ "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
{ "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
{ "Preferences", GTK_STOCK_PREFERENCES, NULL, "<Control>p", NULL, G_CALLBACK(preferences) },
<ui> \
<menubar name=\"MainMenu\"> \
<menu name=\"FileMenu\" action=\"FileMenuAction\"> \
+ <menuitem name=\"New\" action=\"NewFile\" /> \
+ <separator name=\"Separator1\"/> \
<menuitem name=\"Open\" action=\"OpenFile\" /> \
<menuitem name=\"Save\" action=\"SaveFile\" /> \
- <separator name=\"Separator\"/> \
- <menuitem name=\"Preferences\" action=\"Preferences\" /> \
<separator name=\"Separator2\"/> \
+ <menuitem name=\"Preferences\" action=\"Preferences\" /> \
+ <separator name=\"Separator3\"/> \
<menuitem name=\"Quit\" action=\"Quit\" /> \
</menu> \
<menu name=\"ViewMenu\" action=\"ViewMenuAction\"> \
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
}
-static void init_ui(int *argc, char **argv[], struct gui *ui)
+static void combo_entry_changed(GtkComboBox *box, gpointer data)
{
- GtkSettings *settings;
- GtkUIManager *uimanager;
- GtkWidget *menu, *probe, *probe_frame, *probe_box;
+ struct gui_entry *ge = (struct gui_entry *) data;
+ gint index;
- memset(ui, 0, sizeof(*ui));
+ index = gtk_combo_box_get_active(box);
- /* Magical g*thread incantation, you just need this thread stuff.
- * Without it, the update that happens in gfio_update_thread_status
- * doesn't really happen in a timely fashion, you need expose events
- */
- if (!g_thread_supported())
- g_thread_init(NULL);
- gdk_threads_init();
+ multitext_set_entry(&ge->eta.iotype, index);
+ multitext_set_entry(&ge->eta.ioengine, index);
+ multitext_set_entry(&ge->eta.iodepth, index);
+}
- gtk_init(argc, argv);
- settings = gtk_settings_get_default();
- gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
- g_type_init();
-
- ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
- gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
- gtk_window_set_default_size(GTK_WINDOW(ui->window), 700, 500);
+static void combo_entry_destroy(GtkWidget *widget, gpointer data)
+{
+ struct gui_entry *ge = (struct gui_entry *) data;
- g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
- g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
+ multitext_free(&ge->eta.iotype);
+ multitext_free(&ge->eta.ioengine);
+ multitext_free(&ge->eta.iodepth);
+}
- ui->vbox = gtk_vbox_new(FALSE, 0);
- gtk_container_add(GTK_CONTAINER (ui->window), ui->vbox);
+static GtkWidget *new_client_page(struct gui_entry *ge)
+{
+ GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
+ GdkColor white;
- uimanager = gtk_ui_manager_new();
- menu = get_menubar_menu(ui->window, uimanager, ui);
- gfio_ui_setup(settings, menu, ui->vbox, uimanager);
+ main_vbox = gtk_vbox_new(FALSE, 3);
- /*
- * Set up alignments for widgets at the top of ui,
- * align top left, expand horizontally but not vertically
- */
- ui->topalign = gtk_alignment_new(0, 0, 1, 0);
- ui->topvbox = gtk_vbox_new(FALSE, 3);
- gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
- gtk_box_pack_start(GTK_BOX(ui->vbox), ui->topalign, FALSE, FALSE, 0);
+ ge->topalign = gtk_alignment_new(0, 0, 1, 0);
+ ge->topvbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(ge->topalign), ge->topvbox);
+ gtk_box_pack_start(GTK_BOX(main_vbox), ge->topalign, FALSE, FALSE, 0);
probe = gtk_frame_new("Job");
- gtk_box_pack_start(GTK_BOX(ui->topvbox), probe, TRUE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
probe_frame = gtk_vbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(probe), probe_frame);
probe_box = gtk_hbox_new(FALSE, 3);
- gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
- ui->probe.hostname = new_info_label_in_frame(probe_box, "Host");
- ui->probe.os = new_info_label_in_frame(probe_box, "OS");
- ui->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
- ui->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
+ gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
+ ge->probe.hostname = new_info_label_in_frame(probe_box, "Host");
+ ge->probe.os = new_info_label_in_frame(probe_box, "OS");
+ ge->probe.arch = new_info_label_in_frame(probe_box, "Architecture");
+ ge->probe.fio_ver = new_info_label_in_frame(probe_box, "Fio version");
probe_box = gtk_hbox_new(FALSE, 3);
- gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
- ui->eta.name = new_info_entry_in_frame(probe_box, "Name");
- ui->eta.iotype = new_info_entry_in_frame(probe_box, "IO");
- ui->eta.ioengine = new_info_entry_in_frame(probe_box, "IO Engine");
- ui->eta.iodepth = new_info_entry_in_frame(probe_box, "IO Depth");
- ui->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
- ui->eta.files = new_info_entry_in_frame(probe_box, "Open files");
+ ge->eta.names = new_combo_entry_in_frame(probe_box, "Jobs");
+ g_signal_connect(ge->eta.names, "changed", G_CALLBACK(combo_entry_changed), ge);
+ g_signal_connect(ge->eta.names, "destroy", G_CALLBACK(combo_entry_destroy), ge);
+ ge->eta.iotype.entry = new_info_entry_in_frame(probe_box, "IO");
+ ge->eta.ioengine.entry = new_info_entry_in_frame(probe_box, "IO Engine");
+ ge->eta.iodepth.entry = new_info_entry_in_frame(probe_box, "IO Depth");
+ ge->eta.jobs = new_info_entry_in_frame(probe_box, "Jobs");
+ ge->eta.files = new_info_entry_in_frame(probe_box, "Open files");
+ probe_box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
+ ge->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
+ ge->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
+ ge->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
+ ge->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS");
+
+ /*
+ * Only add this if we have a commit rate
+ */
+#if 0
probe_box = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3);
+
+ ge->eta.cr_bw = new_info_label_in_frame(probe_box, "Commit BW");
+ ge->eta.cr_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
+
+ ge->eta.cw_bw = new_info_label_in_frame(probe_box, "Commit BW");
+ ge->eta.cw_iops = new_info_label_in_frame(probe_box, "Commit IOPS");
+#endif
+
+ /*
+ * Set up a drawing area and IOPS and bandwidth graphs
+ */
+ gdk_color_parse("white", &white);
+ ge->graphs.drawing_area = gtk_drawing_area_new();
+ gtk_widget_set_size_request(GTK_WIDGET(ge->graphs.drawing_area),
+ DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
+ gtk_widget_modify_bg(ge->graphs.drawing_area, GTK_STATE_NORMAL, &white);
+ g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "expose_event",
+ G_CALLBACK(on_expose_drawing_area), &ge->graphs);
+ g_signal_connect(G_OBJECT(ge->graphs.drawing_area), "configure_event",
+ G_CALLBACK(on_config_drawing_area), &ge->graphs);
+ ge->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
+ gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ge->scrolled_window),
+ GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ge->scrolled_window),
+ ge->graphs.drawing_area);
+ gtk_box_pack_start(GTK_BOX(main_vbox), ge->scrolled_window,
+ TRUE, TRUE, 0);
+
+ setup_graphs(&ge->graphs);
+
+ /*
+ * Set up alignments for widgets at the bottom of ui,
+ * align bottom left, expand horizontally but not vertically
+ */
+ ge->bottomalign = gtk_alignment_new(0, 1, 1, 0);
+ ge->buttonbox = gtk_hbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(ge->bottomalign), ge->buttonbox);
+ gtk_box_pack_start(GTK_BOX(main_vbox), ge->bottomalign,
+ FALSE, FALSE, 0);
+
+ add_buttons(ge, buttonspeclist, ARRAYSIZE(buttonspeclist));
+
+ /*
+ * Set up thread status progress bar
+ */
+ ge->thread_status_pb = gtk_progress_bar_new();
+ gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(ge->thread_status_pb), 0.0);
+ gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ge->thread_status_pb), "No connections");
+ gtk_container_add(GTK_CONTAINER(ge->buttonbox), ge->thread_status_pb);
+
+
+ return main_vbox;
+}
+
+static GtkWidget *new_main_page(struct gui *ui)
+{
+ GtkWidget *main_vbox, *probe, *probe_frame, *probe_box;
+ GdkColor white;
+
+ main_vbox = gtk_vbox_new(FALSE, 3);
+
+ /*
+ * Set up alignments for widgets at the top of ui,
+ * align top left, expand horizontally but not vertically
+ */
+ ui->topalign = gtk_alignment_new(0, 0, 1, 0);
+ ui->topvbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(ui->topalign), ui->topvbox);
+ gtk_box_pack_start(GTK_BOX(main_vbox), ui->topalign, FALSE, FALSE, 0);
+
+ probe = gtk_frame_new("Run statistics");
+ gtk_box_pack_start(GTK_BOX(main_vbox), probe, FALSE, FALSE, 3);
+ probe_frame = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(probe), probe_frame);
+
+ probe_box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, FALSE, FALSE, 3);
+ ui->eta.jobs = new_info_entry_in_frame(probe_box, "Running");
ui->eta.read_bw = new_info_entry_in_frame(probe_box, "Read BW");
ui->eta.read_iops = new_info_entry_in_frame(probe_box, "IOPS");
ui->eta.write_bw = new_info_entry_in_frame(probe_box, "Write BW");
#endif
/*
- * Add a text box for text op messages
+ * Set up a drawing area and IOPS and bandwidth graphs
*/
- ui->textview = gtk_text_view_new();
- ui->text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(ui->textview));
- gtk_text_buffer_set_text(ui->text, "", -1);
- gtk_text_view_set_editable(GTK_TEXT_VIEW(ui->textview), FALSE);
- gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(ui->textview), FALSE);
+ gdk_color_parse("white", &white);
+ ui->graphs.drawing_area = gtk_drawing_area_new();
+ gtk_widget_set_size_request(GTK_WIDGET(ui->graphs.drawing_area),
+ DRAWING_AREA_XDIM, DRAWING_AREA_YDIM);
+ gtk_widget_modify_bg(ui->graphs.drawing_area, GTK_STATE_NORMAL, &white);
+ g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "expose_event",
+ G_CALLBACK(on_expose_drawing_area), &ui->graphs);
+ g_signal_connect(G_OBJECT(ui->graphs.drawing_area), "configure_event",
+ G_CALLBACK(on_config_drawing_area), &ui->graphs);
ui->scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ui->scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
- gtk_container_add(GTK_CONTAINER(ui->scrolled_window), ui->textview);
- gtk_box_pack_start(GTK_BOX(ui->vbox), ui->scrolled_window,
+ gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(ui->scrolled_window),
+ ui->graphs.drawing_area);
+ gtk_box_pack_start(GTK_BOX(main_vbox), ui->scrolled_window,
TRUE, TRUE, 0);
+ setup_graphs(&ui->graphs);
+
/*
* Set up alignments for widgets at the bottom of ui,
* align bottom left, expand horizontally but not vertically
ui->bottomalign = gtk_alignment_new(0, 1, 1, 0);
ui->buttonbox = gtk_hbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(ui->bottomalign), ui->buttonbox);
- gtk_box_pack_start(GTK_BOX(ui->vbox), ui->bottomalign,
+ gtk_box_pack_start(GTK_BOX(main_vbox), ui->bottomalign,
FALSE, FALSE, 0);
- add_buttons(ui, buttonspeclist, ARRAYSIZE(buttonspeclist));
-
/*
* Set up thread status progress bar
*/
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(ui->thread_status_pb), "No connections");
gtk_container_add(GTK_CONTAINER(ui->buttonbox), ui->thread_status_pb);
+ return main_vbox;
+}
+
+static gboolean notebook_switch_page(GtkNotebook *notebook, GtkWidget *widget,
+ guint page, gpointer data)
+
+{
+ return TRUE;
+}
+
+static void init_ui(int *argc, char **argv[], struct gui *ui)
+{
+ GtkSettings *settings;
+ GtkUIManager *uimanager;
+ GtkWidget *menu, *vbox;
+
+ /* Magical g*thread incantation, you just need this thread stuff.
+ * Without it, the update that happens in gfio_update_thread_status
+ * doesn't really happen in a timely fashion, you need expose events
+ */
+ if (!g_thread_supported())
+ g_thread_init(NULL);
+ gdk_threads_init();
+
+ gtk_init(argc, argv);
+ settings = gtk_settings_get_default();
+ gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "gfio setting");
+ g_type_init();
+
+ ui->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_title(GTK_WINDOW(ui->window), "fio");
+ gtk_window_set_default_size(GTK_WINDOW(ui->window), 1024, 768);
+
+ g_signal_connect(ui->window, "delete-event", G_CALLBACK(quit_clicked), NULL);
+ g_signal_connect(ui->window, "destroy", G_CALLBACK(quit_clicked), NULL);
+
+ ui->vbox = gtk_vbox_new(FALSE, 0);
+ gtk_container_add(GTK_CONTAINER(ui->window), ui->vbox);
+
+ uimanager = gtk_ui_manager_new();
+ menu = get_menubar_menu(ui->window, uimanager, ui);
+ gfio_ui_setup(settings, menu, ui->vbox, uimanager);
+
+ ui->notebook = gtk_notebook_new();
+ g_signal_connect(ui->notebook, "switch-page", G_CALLBACK(notebook_switch_page), ui);
+ gtk_notebook_set_scrollable(GTK_NOTEBOOK(ui->notebook), 1);
+ gtk_notebook_popup_enable(GTK_NOTEBOOK(ui->notebook));
+ gtk_container_add(GTK_CONTAINER(ui->vbox), ui->notebook);
+
+ vbox = new_main_page(ui);
+
+ gtk_notebook_append_page(GTK_NOTEBOOK(ui->notebook), vbox, gtk_label_new("Main"));
+
gfio_ui_setup_log(ui);
gtk_widget_show_all(ui->window);
if (fio_init_options())
return 1;
- init_ui(&argc, &argv, &ui);
+ memset(&main_ui, 0, sizeof(main_ui));
+ INIT_FLIST_HEAD(&main_ui.list);
+
+ init_ui(&argc, &argv, &main_ui);
gdk_threads_enter();
gtk_main();
projects / fio.git / blobdiff