gtk_label_set_text(GTK_LABEL(ui->eta.write_iops), "");
}
+static GtkWidget *new_info_entry_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *entry, *frame;
+
+ frame = gtk_frame_new(label);
+ entry = gtk_entry_new();
+ gtk_entry_set_editable(GTK_ENTRY(entry), 0);
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), entry);
+
+ return entry;
+}
+
+static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
+{
+ GtkWidget *label_widget;
+ GtkWidget *frame;
+
+ frame = gtk_frame_new(label);
+ label_widget = gtk_label_new(NULL);
+ gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), label_widget);
+
+ return label_widget;
+}
+
+static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
+{
+ GtkWidget *button, *box;
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(hbox), box);
+
+ button = gtk_spin_button_new_with_range(min, max, 1.0);
+ gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
+
+ gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
+ gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
+
+ return button;
+}
+
static void gfio_set_connected(struct gui *ui, int connected)
{
if (connected) {
ui->connected = 0;
gtk_button_set_label(GTK_BUTTON(ui->button[CONNECT_BUTTON]), "Connect");
gtk_widget_set_sensitive(ui->button[START_JOB_BUTTON], 0);
- clear_ui_info(ui);
}
}
-static void gfio_text_op(struct fio_client *client,
- FILE *f, __u16 pdu_len, const char *buf)
+static void label_set_int_value(GtkWidget *entry, unsigned int val)
+{
+ char tmp[80];
+
+ sprintf(tmp, "%u", val);
+ gtk_label_set_text(GTK_LABEL(entry), tmp);
+}
+
+static void entry_set_int_value(GtkWidget *entry, unsigned int val)
+{
+ char tmp[80];
+
+ sprintf(tmp, "%u", val);
+ gtk_entry_set_text(GTK_ENTRY(entry), tmp);
+}
+
+#define ALIGN_LEFT 1
+#define ALIGN_RIGHT 2
+#define INVISIBLE 4
+#define UNSORTABLE 8
+
+GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title, unsigned int flags)
+{
+ GtkCellRenderer *renderer;
+ GtkTreeViewColumn *col;
+ double xalign = 0.0; /* left as default */
+ PangoAlignment align;
+ gboolean visible;
+
+ align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
+ (flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
+ PANGO_ALIGN_CENTER;
+ visible = !(flags & INVISIBLE);
+
+ renderer = gtk_cell_renderer_text_new();
+ col = gtk_tree_view_column_new();
+
+ gtk_tree_view_column_set_title(col, title);
+ if (!(flags & UNSORTABLE))
+ gtk_tree_view_column_set_sort_column_id(col, index);
+ gtk_tree_view_column_set_resizable(col, TRUE);
+ gtk_tree_view_column_pack_start(col, renderer, TRUE);
+ gtk_tree_view_column_add_attribute(col, renderer, "text", index);
+ gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
+ switch (align) {
+ case PANGO_ALIGN_LEFT:
+ xalign = 0.0;
+ break;
+ case PANGO_ALIGN_CENTER:
+ xalign = 0.5;
+ break;
+ case PANGO_ALIGN_RIGHT:
+ xalign = 1.0;
+ break;
+ }
+ gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
+ gtk_tree_view_column_set_visible(col, visible);
+ gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
+ return col;
+}
+
+static GtkWidget *gfio_output_clat_percentiles(unsigned int *ovals,
+ fio_fp64_t *plist,
+ unsigned int len,
+ const char *base,
+ unsigned int scale)
+{
+ GType types[FIO_IO_U_LIST_MAX_LEN];
+ GtkWidget *tree_view;
+ GtkTreeSelection *selection;
+ GtkListStore *model;
+ GtkTreeIter iter;
+ int i;
+
+ for (i = 0; i < len; i++)
+ types[i] = G_TYPE_INT;
+
+ model = gtk_list_store_newv(len, types);
+
+ tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(model));
+ gtk_widget_set_can_focus(tree_view, FALSE);
+
+ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_view));
+ gtk_tree_selection_set_mode(GTK_TREE_SELECTION(selection), GTK_SELECTION_BROWSE);
+
+ for (i = 0; i < len; i++) {
+ char fbuf[8];
+
+ sprintf(fbuf, "%2.2f%%", plist[i].u.f);
+ tree_view_column(tree_view, i, fbuf, ALIGN_RIGHT | UNSORTABLE);
+ }
+
+ gtk_list_store_append(model, &iter);
+
+ for (i = 0; i < len; i++)
+ gtk_list_store_set(model, &iter, i, ovals[i], -1);
+
+ return tree_view;
+}
+
+static void gfio_show_clat_percentiles(GtkWidget *vbox, struct thread_stat *ts,
+ int ddir)
+{
+ unsigned int *io_u_plat = ts->io_u_plat[ddir];
+ unsigned long nr = ts->clat_stat[ddir].samples;
+ fio_fp64_t *plist = ts->percentile_list;
+ unsigned int *ovals, len, minv, maxv, scale_down;
+ const char *base;
+ GtkWidget *tree_view, *frame, *hbox;
+ char tmp[64];
+
+ len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv);
+ if (!len)
+ goto out;
+
+ /*
+ * We default to usecs, but if the value range is such that we
+ * should scale down to msecs, do that.
+ */
+ if (minv > 2000 && maxv > 99999) {
+ scale_down = 1;
+ base = "msec";
+ } else {
+ scale_down = 0;
+ base = "usec";
+ }
+
+ tree_view = gfio_output_clat_percentiles(ovals, plist, len, base, scale_down);
+
+ sprintf(tmp, "Completion percentiles (%s)", base);
+ frame = gtk_frame_new(tmp);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), hbox);
+
+ gtk_box_pack_start(GTK_BOX(hbox), tree_view, TRUE, FALSE, 3);
+out:
+ if (ovals)
+ free(ovals);
+}
+
+static void gfio_show_lat(GtkWidget *vbox, const char *name, unsigned long min,
+ unsigned long max, double mean, double dev)
+{
+ const char *base = "(usec)";
+ GtkWidget *hbox, *label, *frame;
+ char *minp, *maxp;
+ char tmp[64];
+
+ if (!usec_to_msec(&min, &max, &mean, &dev))
+ base = "(msec)";
+
+ minp = num2str(min, 6, 1, 0);
+ maxp = num2str(max, 6, 1, 0);
+
+ sprintf(tmp, "%s %s", name, base);
+ frame = gtk_frame_new(tmp);
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ hbox = gtk_hbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), hbox);
+
+ label = new_info_label_in_frame(hbox, "Minimum");
+ gtk_label_set_text(GTK_LABEL(label), minp);
+ label = new_info_label_in_frame(hbox, "Maximum");
+ gtk_label_set_text(GTK_LABEL(label), maxp);
+ label = new_info_label_in_frame(hbox, "Average");
+ sprintf(tmp, "%5.02f", mean);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+ label = new_info_label_in_frame(hbox, "Standard deviation");
+ sprintf(tmp, "%5.02f", dev);
+ gtk_label_set_text(GTK_LABEL(label), tmp);
+
+ free(minp);
+ free(maxp);
+
+}
+
+static void gfio_show_ddir_status(GtkWidget *mbox, struct group_run_stats *rs,
+ struct thread_stat *ts, int ddir)
+{
+ const char *ddir_label[2] = { "Read", "Write" };
+ GtkWidget *frame, *label, *box, *vbox;
+ unsigned long min, max, runt;
+ unsigned long long bw, iops;
+ double mean, dev;
+ char *io_p, *bw_p, *iops_p;
+ int i2p;
+
+ if (!ts->runtime[ddir])
+ return;
+
+ i2p = is_power_of_2(rs->kb_base);
+ runt = ts->runtime[ddir];
+
+ bw = (1000 * ts->io_bytes[ddir]) / runt;
+ io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p);
+ bw_p = num2str(bw, 6, 1, i2p);
+
+ iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt;
+ iops_p = num2str(iops, 6, 1, 0);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(mbox), box, TRUE, FALSE, 3);
+
+ frame = gtk_frame_new(ddir_label[ddir]);
+ gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5);
+
+ vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+
+ box = gtk_hbox_new(FALSE, 3);
+ gtk_box_pack_start(GTK_BOX(vbox), box, TRUE, FALSE, 3);
+
+ label = new_info_label_in_frame(box, "IO");
+ gtk_label_set_text(GTK_LABEL(label), io_p);
+ label = new_info_label_in_frame(box, "Bandwidth");
+ gtk_label_set_text(GTK_LABEL(label), bw_p);
+ label = new_info_label_in_frame(box, "IOPS");
+ gtk_label_set_text(GTK_LABEL(label), iops_p);
+ label = new_info_label_in_frame(box, "Runtime (msec)");
+ label_set_int_value(label, ts->runtime[ddir]);
+
+ frame = gtk_frame_new("Latency");
+ gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
+
+ vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(frame), vbox);
+
+ if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev))
+ gfio_show_lat(vbox, "Submission latency", min, max, mean, dev);
+ if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev))
+ gfio_show_lat(vbox, "Completion latency", min, max, mean, dev);
+ if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev))
+ gfio_show_lat(vbox, "Total latency", min, max, mean, dev);
+ if (ts->clat_percentiles)
+ gfio_show_clat_percentiles(vbox, ts, ddir);
+
+ free(io_p);
+ free(bw_p);
+ free(iops_p);
+}
+
+static void gfio_display_ts(struct fio_client *client, struct thread_stat *ts,
+ struct group_run_stats *rs)
+{
+ GtkWidget *dialog, *box, *vbox, *entry, *content;
+ struct gui *ui = client->client_data;
+
+ gdk_threads_enter();
+
+ dialog = gtk_dialog_new_with_buttons("Results", GTK_WINDOW(ui->window),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);
+
+ g_signal_connect_swapped(dialog, "response",
+ G_CALLBACK(gtk_widget_destroy),
+ dialog);
+
+ content = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
+
+ vbox = gtk_vbox_new(FALSE, 3);
+ gtk_container_add(GTK_CONTAINER(content), vbox);
+
+ box = gtk_hbox_new(TRUE, 3);
+ gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 5);
+
+ entry = new_info_entry_in_frame(box, "Name");
+ gtk_entry_set_text(GTK_ENTRY(entry), ts->name);
+ if (strlen(ts->description)) {
+ entry = new_info_entry_in_frame(box, "Description");
+ gtk_entry_set_text(GTK_ENTRY(entry), ts->description);
+ }
+ entry = new_info_entry_in_frame(box, "Group ID");
+ 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");
+ entry_set_int_value(entry, ts->error);
+ entry = new_info_entry_in_frame(box, "PID");
+ entry_set_int_value(entry, ts->pid);
+
+ if (ts->io_bytes[DDIR_READ])
+ gfio_show_ddir_status(vbox, rs, ts, DDIR_READ);
+ if (ts->io_bytes[DDIR_WRITE])
+ gfio_show_ddir_status(vbox, rs, ts, DDIR_WRITE);
+
+ gtk_widget_show_all(dialog);
+
+ gdk_threads_leave();
+}
+
+static void gfio_text_op(struct fio_client *client, struct fio_net_cmd *cmd)
{
#if 0
GtkTextBuffer *buffer;
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(ui.textview),
&end, 0.0, FALSE, 0.0,0.0);
#else
- fio_client_ops.text_op(client, f, pdu_len, buf);
+ fio_client_ops.text_op(client, cmd);
#endif
}
fio_client_ops.disk_util(client, cmd);
}
-static void gfio_thread_status_op(struct fio_net_cmd *cmd)
+extern int sum_stat_clients;
+extern struct thread_stat client_ts;
+extern struct group_run_stats client_gs;
+
+static int sum_stat_nr;
+
+static void gfio_thread_status_op(struct fio_client *client,
+ struct fio_net_cmd *cmd)
{
- printf("gfio_thread_status_op called\n");
- fio_client_ops.thread_status(cmd);
+ struct cmd_ts_pdu *p = (struct cmd_ts_pdu *) cmd->payload;
+
+ gfio_display_ts(client, &p->ts, &p->rs);
+
+ if (sum_stat_clients == 1)
+ return;
+
+ sum_thread_stats(&client_ts, &p->ts, sum_stat_nr);
+ sum_group_stats(&client_gs, &p->rs);
+
+ client_ts.members++;
+ client_ts.groupid = p->ts.groupid;
+
+ if (++sum_stat_nr == sum_stat_clients) {
+ strcpy(client_ts.name, "All clients");
+ gfio_display_ts(client, &client_ts, &client_gs);
+ }
}
-static void gfio_group_stats_op(struct fio_net_cmd *cmd)
+static void gfio_group_stats_op(struct fio_client *client,
+ struct fio_net_cmd *cmd)
{
printf("gfio_group_stats_op called\n");
- fio_client_ops.group_stats(cmd);
+ fio_client_ops.group_stats(client, cmd);
}
static void gfio_update_eta(struct jobs_eta *je)
gfio_update_thread_status(output, perc);
}
-static void gfio_eta_op(struct fio_client *client, struct fio_net_cmd *cmd)
-{
- struct jobs_eta *je = (struct jobs_eta *) cmd->payload;
- struct client_eta *eta = (struct client_eta *) (uintptr_t) cmd->tag;
-
- client->eta_in_flight = NULL;
- flist_del_init(&client->eta_list);
-
- fio_client_convert_jobs_eta(je);
- fio_client_sum_jobs_eta(&eta->eta, je);
- fio_client_dec_jobs_eta(eta, gfio_update_eta);
-}
-
static void gfio_probe_op(struct fio_client *client, struct fio_net_cmd *cmd)
{
struct cmd_probe_pdu *probe = (struct cmd_probe_pdu *) cmd->payload;
gdk_threads_enter();
gfio_set_connected(ui, 0);
+ clear_ui_info(ui);
sprintf(buf, "Client %s: timeout talking to server.\n", client->hostname);
.disk_util = gfio_disk_util_op,
.thread_status = gfio_thread_status_op,
.group_stats = gfio_group_stats_op,
- .eta = gfio_eta_op,
+ .eta = gfio_update_eta,
.probe = gfio_probe_op,
.quit = gfio_quit_op,
.add_job = gfio_add_job_op,
}
}
-static GtkWidget *new_info_label_in_frame(GtkWidget *box, const char *label)
-{
- GtkWidget *label_widget;
- GtkWidget *frame;
-
- frame = gtk_frame_new(label);
- label_widget = gtk_label_new(NULL);
- gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 3);
- gtk_container_add(GTK_CONTAINER(frame), label_widget);
-
- return label_widget;
-}
-
-static GtkWidget *create_spinbutton(GtkWidget *hbox, double min, double max, double defval)
-{
- GtkWidget *button, *box;
-
- box = gtk_hbox_new(FALSE, 3);
- gtk_container_add(GTK_CONTAINER(hbox), box);
-
- button = gtk_spin_button_new_with_range(min, max, 1.0);
- gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
-
- gtk_spin_button_set_update_policy(GTK_SPIN_BUTTON(button), GTK_UPDATE_IF_VALID);
- gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), defval);
-
- return button;
-}
-
static void start_job_clicked(__attribute__((unused)) GtkWidget *widget,
gpointer data)
{
} else {
fio_clients_terminate();
gfio_set_connected(ui, 0);
+ clear_ui_info(ui);
}
}
ui.job_files[ui.nr_job_files] = strdup(filenames->data);
ui.nr_job_files++;
- ui.client = fio_client_add_explicit(host, type, port);
+ ui.client = fio_client_add_explicit(&gfio_client_ops, host, type, port);
if (!ui.client) {
GError *error;
gtk_widget_destroy(dialog);
}
+static void preferences(GtkWidget *w, gpointer data)
+{
+ GtkWidget *dialog, *frame, *box, **buttons;
+ int i;
+
+ dialog = gtk_dialog_new_with_buttons("Preferences",
+ GTK_WINDOW(ui.window),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
+ GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
+ NULL);
+
+ frame = gtk_frame_new("Debug logging");
+ gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
+ box = gtk_hbox_new(FALSE, 6);
+ gtk_container_add(GTK_CONTAINER(frame), box);
+
+ buttons = malloc(sizeof(GtkWidget *) * FD_DEBUG_MAX);
+
+ for (i = 0; i < FD_DEBUG_MAX; i++) {
+ 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);
+ }
+
+ gtk_widget_show_all(dialog);
+
+ if (gtk_dialog_run(GTK_DIALOG(dialog)) != GTK_RESPONSE_ACCEPT) {
+ gtk_widget_destroy(dialog);
+ return;
+ }
+
+ for (i = 0; i < FD_DEBUG_MAX; i++) {
+ int set;
+
+ set = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(buttons[i]));
+ if (set)
+ fio_debug |= (1UL << i);
+ }
+
+ gtk_widget_destroy(dialog);
+}
+
static void about_dialog(GtkWidget *w, gpointer data)
{
gtk_show_about_dialog(NULL,
}
static GtkActionEntry menu_items[] = {
- { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
- { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
- { "OpenFile", GTK_STOCK_OPEN, NULL, "<Control>O", NULL, G_CALLBACK(file_open) },
- { "SaveFile", GTK_STOCK_SAVE, NULL, "<Control>S", NULL, G_CALLBACK(file_save) },
- { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
- { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
+ { "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
+ { "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
+ { "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) },
+ { "Quit", GTK_STOCK_QUIT, NULL, "<Control>Q", NULL, G_CALLBACK(quit_clicked) },
+ { "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
};
static gint nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
<menuitem name=\"Open\" action=\"OpenFile\" /> \
<menuitem name=\"Save\" action=\"SaveFile\" /> \
<separator name=\"Separator\"/> \
+ <menuitem name=\"Preferences\" action=\"Preferences\" /> \
+ <separator name=\"Separator2\"/> \
<menuitem name=\"Quit\" action=\"Quit\" /> \
</menu> \
<menu name=\"Help\" action=\"HelpMenuAction\"> \
if (fio_init_options())
return 1;
- fio_debug = ~0UL;
init_ui(&argc, &argv, &ui);
gdk_threads_enter();
projects / fio.git / blobdiff