X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=gfio.c;h=062f63fdd8e7ffe6e971f3ebd4bcb42678643a14;hp=157dd667f4ed928aca615626aa93f39deb4f4a4c;hb=ca850992888df61f347ad839be0c4091ff25bea3;hpb=a52766160d7f2a937c74d4adee1819ef00467d4b diff --git a/gfio.c b/gfio.c index 157dd667..062f63fd 100644 --- a/gfio.c +++ b/gfio.c @@ -105,16 +105,58 @@ static void clear_ui_info(struct gui *ui) 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_label_set_text(GTK_LABEL(ui->eta.name), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.iotype), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.ioengine), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.iodepth), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.jobs), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.files), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.read_bw), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.read_iops), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.write_bw), ""); - gtk_label_set_text(GTK_LABEL(ui->eta.write_iops), ""); + 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), ""); +} + +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) @@ -130,6 +172,356 @@ static void gfio_set_connected(struct gui *ui, int connected) } } +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); + +} + +#define GFIO_CLAT 1 +#define GFIO_SLAT 2 +#define GFIO_LAT 4 + +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; + unsigned int flags = 0; + 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]); + + if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev)) + flags |= GFIO_SLAT; + if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev)) + flags |= GFIO_CLAT; + if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev)) + flags |= GFIO_LAT; + + if (flags) { + 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 (flags & GFIO_SLAT) + gfio_show_lat(vbox, "Submission latency", min, max, mean, dev); + if (flags & GFIO_CLAT) + gfio_show_lat(vbox, "Completion latency", min, max, mean, dev); + if (flags & GFIO_LAT) + gfio_show_lat(vbox, "Total latency", min, max, mean, dev); + } + + if (ts->clat_percentiles) + gfio_show_clat_percentiles(vbox, ts, ddir); + + if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { + double p_of_agg = 100.0; + const char *bw_str = "KB"; + char tmp[32]; + + if (rs->agg[ddir]) { + p_of_agg = mean * 100 / (double) rs->agg[ddir]; + if (p_of_agg > 100.0) + p_of_agg = 100.0; + } + + if (mean > 999999.9) { + min /= 1000.0; + max /= 1000.0; + mean /= 1000.0; + dev /= 1000.0; + bw_str = "MB"; + } + + frame = gtk_frame_new("Bandwidth"); + gtk_box_pack_start(GTK_BOX(box), frame, FALSE, FALSE, 5); + + vbox = gtk_vbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(frame), vbox); + + label = new_info_label_in_frame(vbox, "Bandwidth"); + gtk_label_set_text(GTK_LABEL(label), bw_str); + label = new_info_label_in_frame(vbox, "Minimum"); + label_set_int_value(label, min); + label = new_info_label_in_frame(vbox, "Maximum"); + label_set_int_value(label, max); + label = new_info_label_in_frame(vbox, "Percentage of jobs"); + sprintf(tmp, "%3.2f%%", p_of_agg); + gtk_label_set_text(GTK_LABEL(label), tmp); + label = new_info_label_in_frame(vbox, "Average"); + sprintf(tmp, "%5.02f", mean); + gtk_label_set_text(GTK_LABEL(label), tmp); + label = new_info_label_in_frame(vbox, "Standard deviation"); + sprintf(tmp, "%5.02f", dev); + gtk_label_set_text(GTK_LABEL(label), tmp); + } + + 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 @@ -154,16 +546,39 @@ static void gfio_disk_util_op(struct fio_client *client, struct fio_net_cmd *cmd 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) @@ -184,9 +599,9 @@ static void gfio_update_eta(struct jobs_eta *je) } sprintf(tmp, "%u", je->nr_running); - gtk_label_set_text(GTK_LABEL(ui.eta.jobs), tmp); + gtk_entry_set_text(GTK_ENTRY(ui.eta.jobs), tmp); sprintf(tmp, "%u", je->files_open); - gtk_label_set_text(GTK_LABEL(ui.eta.files), tmp); + gtk_entry_set_text(GTK_ENTRY(ui.eta.files), tmp); #if 0 if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) { @@ -195,17 +610,17 @@ static void gfio_update_eta(struct jobs_eta *je) mr = num2str(je->m_rate, 4, 0, i2p); tr = num2str(je->t_rate, 4, 0, i2p); - gtk_label_set_text(GTK_LABEL(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_label_set_text(GTK_LABEL(ui.eta.cr_bw), "---"); - gtk_label_set_text(GTK_LABEL(ui.eta.cr_iops), "---"); - gtk_label_set_text(GTK_LABEL(ui.eta.cw_bw), "---"); - gtk_label_set_text(GTK_LABEL(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 if (je->eta_sec != INT_MAX && je->nr_running) { @@ -226,10 +641,10 @@ static void gfio_update_eta(struct jobs_eta *je) iops_str[0] = num2str(je->iops[0], 4, 1, 0); iops_str[1] = num2str(je->iops[1], 4, 1, 0); - gtk_label_set_text(GTK_LABEL(ui.eta.read_bw), rate_str[0]); - gtk_label_set_text(GTK_LABEL(ui.eta.read_iops), iops_str[0]); - gtk_label_set_text(GTK_LABEL(ui.eta.write_bw), rate_str[1]); - gtk_label_set_text(GTK_LABEL(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]); free(rate_str[0]); free(rate_str[1]); @@ -310,12 +725,12 @@ static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd) p->numjobs = le32_to_cpu(p->numjobs); p->group_reporting = le32_to_cpu(p->group_reporting); - gtk_label_set_text(GTK_LABEL(ui->eta.name), (gchar *) p->jobname); - gtk_label_set_text(GTK_LABEL(ui->eta.iotype), ddir_str(p->rw)); - gtk_label_set_text(GTK_LABEL(ui->eta.ioengine), (gchar *) p->ioengine); + 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); sprintf(tmp, "%u", p->iodepth); - gtk_label_set_text(GTK_LABEL(ui->eta.iodepth), tmp); + gtk_entry_set_text(GTK_ENTRY(ui->eta.iodepth), tmp); } static void gfio_client_timed_out(struct fio_client *client) @@ -403,35 +818,6 @@ static void start_job_thread(struct gui *ui) } } -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) { @@ -852,19 +1238,19 @@ static void init_ui(int *argc, char **argv[], struct gui *ui) probe_box = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); - ui->eta.name = new_info_label_in_frame(probe_box, "Name"); - ui->eta.iotype = new_info_label_in_frame(probe_box, "IO"); - ui->eta.ioengine = new_info_label_in_frame(probe_box, "IO Engine"); - ui->eta.iodepth = new_info_label_in_frame(probe_box, "IO Depth"); - ui->eta.jobs = new_info_label_in_frame(probe_box, "Jobs"); - ui->eta.files = new_info_label_in_frame(probe_box, "Open files"); + 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"); probe_box = gtk_hbox_new(FALSE, 3); gtk_box_pack_start(GTK_BOX(probe_frame), probe_box, TRUE, FALSE, 3); - ui->eta.read_bw = new_info_label_in_frame(probe_box, "Read BW"); - ui->eta.read_iops = new_info_label_in_frame(probe_box, "IOPS"); - ui->eta.write_bw = new_info_label_in_frame(probe_box, "Write BW"); - ui->eta.write_iops = new_info_label_in_frame(probe_box, "IOPS"); + 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"); + ui->eta.write_iops = new_info_entry_in_frame(probe_box, "IOPS"); /* * Only add this if we have a commit rate