2 // Copyright (c) 2010-2017 Intel Corporation
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
8 // http://www.apache.org/licenses/LICENSE-2.0
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
19 #include <rte_cycles.h>
25 #include "display_latency.h"
26 #include "display_mempools.h"
27 #include "display_ports.h"
28 #include "display_priority.h"
29 #include "display_rings.h"
30 #include "display_pkt_len.h"
31 #include "display_l4gen.h"
32 #include "display_tasks.h"
41 #include "stats_port.h"
42 #include "stats_latency.h"
43 #include "stats_global.h"
44 #include "stats_core.h"
46 #include "prox_assert.h"
49 #include "prox_port_cfg.h"
51 static struct screen_state screen_state = {
56 static struct display_screen *display_screens[16];
57 static struct display_screen *current_screen;
58 static size_t n_screens;
59 static size_t longest_title;
61 void display_set_pps_unit(int val)
63 screen_state.pps_unit = val;
66 /* Set up the display mutex as recursive. This enables threads to use
67 display_[un]lock() to lock the display when multiple calls to for
68 instance plog_info() need to be made. */
69 static pthread_mutex_t disp_mtx = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
71 static void stats_display_layout(uint8_t in_place);
73 void display_lock(void)
75 pthread_mutex_lock(&disp_mtx);
78 void display_unlock(void)
80 pthread_mutex_unlock(&disp_mtx);
83 /* Advanced text output */
84 static WINDOW *scr = NULL, *win_txt, *win_general, *win_cmd, *win_stat, *win_title, *win_tabs, *win_help;
85 static int win_txt_height = 1;
88 static uint16_t max_n_lines;
90 static int cmd_cursor_pos;
91 static const char *cmd_cmd;
94 /* Colors used in the interface */
114 int display_getch(void)
125 void display_cmd(const char *cmd, int cl, int cursor_pos)
128 if (cursor_pos == -1 || cursor_pos > cmd_len)
129 cursor_pos = cmd_len;
130 cmd_cursor_pos = cursor_pos;
135 if (cursor_pos < cmd_len) {
136 waddnstr(win_cmd, cmd, cursor_pos);
137 wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK));
138 waddnstr(win_cmd, cmd + cursor_pos, 1);
139 wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
140 waddnstr(win_cmd, cmd + cursor_pos + 1, cmd_len - (cursor_pos + 1));
143 waddnstr(win_cmd, cmd, cmd_len);
144 wmove(win_cmd, cursor_pos, 0);
145 wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK));
146 waddstr(win_cmd, " ");
147 wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
150 wattroff(win_stat, A_UNDERLINE);
155 static void refresh_cmd_win(void)
157 display_cmd(cmd_cmd, cmd_len, cmd_cursor_pos);
160 static WINDOW *create_subwindow(int height, int width, int y_pos, int x_pos)
162 WINDOW *win = subwin(scr, height, width, y_pos, x_pos);
167 /* The limit parameter sets the last column that something can be
168 printed. If characters would be printed _past_ the limit, the last
169 character printed within the limit will be a '~' to signify that
170 the string cut off. The limit parameter will be ignored if its
172 static inline int mvwaddstrv(WINDOW *win, int y, int x, int limit, const char *fmt, va_list ap)
177 ret = vsnprintf(buf, sizeof(buf), fmt, ap);
185 /* To prevent strings from wrapping, cut the string at the end
187 if (x + len > COLS) {
188 buf[COLS - 1 - x] = 0;
192 if (limit != -1 && x + len > limit) {
193 int new_len = limit - x;
198 buf[new_len + 1] = 0;
205 /* Format string capable [mv]waddstr() wrappers */
206 __attribute__((format(printf, 4, 5))) static inline int mvwaddstrf(WINDOW* win, int y, int x, const char *fmt, ...)
212 ret = mvwaddstrv(win, y, x, -1, fmt, ap);
217 __attribute__((format(printf, 5, 6))) static inline int mvwaddstrf_limit(WINDOW* win, int y, int x, int limit, const char *fmt, ...)
223 ret = mvwaddstrv(win, y, x, limit, fmt, ap);
228 // red: link down; Green: link up
229 static short link_color(const uint8_t if_port)
231 return COLOR_PAIR(prox_port_cfg[if_port].link_up? GREEN_ON_NOTHING : RED_ON_NOTHING);
234 static void (*ncurses_sigwinch)(int);
236 static void sigwinch(int in)
238 if (ncurses_sigwinch)
239 ncurses_sigwinch(in);
241 stats_display_layout(0);
244 static void set_signal_handler(void)
246 struct sigaction old;
248 sigaction(SIGWINCH, NULL, &old);
249 ncurses_sigwinch = old.sa_handler;
251 signal(SIGWINCH, sigwinch);
254 void display_column_port_ring(const struct display_column *display_column, int row, struct port_queue *ports, int port_count, struct rte_ring **rings, int ring_count)
256 if (row >= max_n_lines)
259 int pos = display_column->offset;
260 int limit = pos + display_column->width;
262 for (int i = 0; i < port_count && pos < limit; i++) {
263 wbkgdset(win_stat, link_color(ports[i].port));
264 pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%u", ports[i].port);
265 wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
267 if (i != port_count - 1)
268 pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, " ");
271 for (uint8_t ring_id = 0; ring_id < ring_count && pos < limit; ++ring_id) {
272 pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%s", rings[ring_id]->name);
276 static void display_add_screen(struct display_screen *screen)
278 display_screens[n_screens++] = screen;
279 if (longest_title < strlen(screen->title))
280 longest_title = strlen(screen->title);
283 static void display_init_screens(void)
288 display_add_screen(display_tasks());
289 display_add_screen(display_ports());
290 display_add_screen(display_mempools());
291 display_add_screen(display_latency());
292 display_add_screen(display_rings());
293 display_add_screen(display_l4gen());
294 display_add_screen(display_pkt_len());
295 display_add_screen(display_priority());
298 void display_init(void)
302 /* Assign default foreground/background colors to color number -1 */
303 use_default_colors();
305 init_pair(NO_COLOR, -1, -1);
306 init_pair(RED_ON_BLACK, COLOR_RED, COLOR_BLACK);
307 init_pair(BLACK_ON_CYAN, COLOR_BLACK, COLOR_CYAN);
308 init_pair(BLACK_ON_GREEN, COLOR_BLACK, COLOR_GREEN);
309 init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);
310 init_pair(BLACK_ON_YELLOW, COLOR_BLACK, COLOR_YELLOW);
311 init_pair(YELLOW_ON_BLACK, COLOR_YELLOW, COLOR_BLACK);
312 init_pair(WHITE_ON_RED, COLOR_WHITE, COLOR_RED);
313 init_pair(YELLOW_ON_NOTHING, COLOR_YELLOW, -1);
314 init_pair(GREEN_ON_NOTHING, COLOR_GREEN, -1);
315 init_pair(RED_ON_NOTHING, COLOR_RED, -1);
316 init_pair(BLUE_ON_NOTHING, COLOR_BLUE, -1);
317 init_pair(CYAN_ON_NOTHING, COLOR_CYAN, -1);
318 init_pair(MAGENTA_ON_NOTHING, COLOR_MAGENTA, -1);
319 init_pair(WHITE_ON_NOTHING, COLOR_WHITE, -1);
320 /* nodelay(scr, TRUE); */
323 /* Create fullscreen log window. When stats are displayed
324 later, it is recreated with appropriate dimensions. */
325 win_txt = create_subwindow(0, 0, 0, 0);
326 wbkgd(win_txt, COLOR_PAIR(0));
328 idlok(win_txt, FALSE);
330 scrollok(win_txt, TRUE);
331 /* Leave cursor where it was */
332 leaveok(win_txt, TRUE);
336 set_signal_handler();
338 max_n_lines = (LINES - 5 - 2 - 3);
339 /* core_port_height = max_n_lines < stats_get_n_tasks_tot()? max_n_lines : stats_get_n_tasks_tot(); */
341 display_init_screens();
343 stats_display_layout(0);
346 static void display_page_recalc_offsets(struct display_page *display_page)
348 struct display_table *table;
349 struct display_column *col;
350 int total_offset = 0;
352 for (int i = 0; i < display_page->n_tables; ++i) {
353 table = &display_page->tables[i];
357 table->offset = total_offset;
358 for (int j = 0; j < table->n_cols; ++j) {
359 col = &table->cols[j];
360 col->offset = total_offset;
361 if (j + 1 != table->n_cols)
363 total_offset += col->width;
365 table->width = total_offset - table->offset;
369 void display_page_init(struct display_page *display_page)
371 struct display_table *table;
372 struct display_column *col;
374 int table_offset = 0;
376 memset(display_page, 0, sizeof(*display_page));
377 display_page->n_tables = 0;
378 for (size_t i = 0; i < sizeof(display_page->tables)/sizeof(display_page->tables[0]); ++i) {
379 table = &display_page->tables[i];
380 for (size_t j = 0; j < sizeof(table->cols)/sizeof(table->cols[0]); ++j) {
381 col = &table->cols[j];
382 col->display_page = display_page;
387 struct display_table *display_page_add_table(struct display_page *display_page)
389 struct display_table *table = &display_page->tables[display_page->n_tables];
391 display_page->n_tables++;
395 void display_table_init(struct display_table *table, const char *title)
397 strcpy(table->title, title);
401 struct display_column *display_table_add_col(struct display_table *table)
403 struct display_column *col = &table->cols[table->n_cols];
409 void display_column_init(struct display_column *display_column, const char *title, unsigned width)
411 if (width < strlen(title))
412 width = strlen(title);
414 strcpy(display_column->title, title);
415 display_column->width = width;
416 display_page_recalc_offsets(display_column->display_page);
419 int display_column_get_width(const struct display_column *display_column)
421 return display_column->width;
424 void display_page_draw_frame(const struct display_page *display_page, int height)
426 const struct display_table *table;
427 const struct display_column *col;
429 wattron(win_stat, A_BOLD);
430 wbkgdset(win_stat, COLOR_PAIR(YELLOW_ON_NOTHING));
432 for (int i = 0; i < display_page->n_tables; ++i) {
433 table = &display_page->tables[i];
436 mvwvline(win_stat, 0, table->offset - 1, ACS_VLINE, height + 2);
438 mvwaddstrf(win_stat, 0, table->offset + table->width / 2 - strlen(table->title) / 2, "%s", table->title);
439 for (int j = 0; j < table->n_cols; ++j) {
440 col = &table->cols[j];
443 mvwvline(win_stat, 1, col->offset - 1, ACS_VLINE, height + 1);
444 mvwaddstrf(win_stat, 1, col->offset + col->width / 2 - strlen(col->title) / 2, "%s", col->title);
447 if (i + 1 == display_page->n_tables)
448 mvwvline(win_stat, 0, table->offset + table->width, ACS_VLINE, height + 2);
450 wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
451 wattroff(win_stat, A_BOLD);
454 void display_column_print(const struct display_column *display_column, int row, const char *fmt, ...)
456 if (row >= max_n_lines)
460 char buffer[128] = {0};
461 char *to_print = buffer + 64;
464 int len = vsnprintf(to_print, sizeof(buffer) - 64, fmt, ap);
468 /* If column is too long, add ~ at the end. If it is too
469 short, align on the right. */
470 if (len > display_column->width) {
471 to_print[display_column->width - 1] = '~';
472 to_print[display_column->width] = '\0';
474 int diff = display_column->width - len;
477 to_print -= display_column->width;
478 for (int i = 0; i < diff; i++)
482 mvwaddstrf(win_stat, row + 2, display_column->offset, "%s", to_print);
485 void display_column_print_core_task(const struct display_column *display_column, int row, struct lcore_cfg *lconf, struct task_args *targ)
487 if (row >= max_n_lines)
490 if (lconf->n_tasks_run == 0) {
491 wattron(win_stat, A_BOLD);
492 wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING));
495 mvwaddstrf(win_stat, row + 2, display_column->offset, "%2u/", lconf->id);
496 if (lconf->n_tasks_run == 0) {
497 wattroff(win_stat, A_BOLD);
498 wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
500 if (!lconf_task_is_running(lconf, targ->id)) {
501 wattron(win_stat, A_BOLD);
502 wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING));
504 mvwaddstrf(win_stat, row + 2, display_column->offset + 3, "%1u", targ->id);
505 if (!lconf_task_is_running(lconf, targ->id)) {
506 wattroff(win_stat, A_BOLD);
507 wbkgdset(win_stat, COLOR_PAIR(NO_COLOR));
511 static void redraw_tabs(unsigned screen_id)
513 const size_t len = longest_title + 1;
515 for (size_t i = 0; i < n_screens; ++i) {
517 wbkgdset(win_tabs, COLOR_PAIR(BLACK_ON_GREEN));
519 mvwaddstrf(win_tabs, 0, i*(len + 3), "%zu ", i+1);
521 wbkgdset(win_tabs, COLOR_PAIR(GREEN_ON_NOTHING));
522 mvwaddstrf(win_tabs, 0, i*(len + 3) + 2, "%s", display_screens[i]->title);
523 for (size_t j = strlen(display_screens[i]->title); j < len - 1; ++j)
524 mvwaddstrf(win_tabs, 0, i*(len + 3) + 2 + j, " ");
526 wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR));
528 wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR));
534 static void draw_title(void)
538 snprintf(title_str, sizeof(title_str), "%s %s: %s", PROGRAM_NAME, VERSION_STR, prox_cfg.name);
540 wbkgd(win_title, COLOR_PAIR(BLACK_ON_GREEN));
541 title_len = strlen(title_str);
542 mvwaddstrf(win_title, 0, (COLS - title_len)/2, "%s", title_str);
544 redraw_tabs(screen_state.chosen_screen);
547 static void draw_general_frame(void)
549 if (screen_state.toggle == 0) {
550 wattron(win_general, A_BOLD);
551 wbkgdset(win_general, COLOR_PAIR(MAGENTA_ON_NOTHING));
552 mvwaddstrf(win_general, 0, 9, "rx: tx: diff: rx: tx: %%:");
553 mvwaddstrf(win_general, 1, 9, "rx: tx: err: rx: tx: err: %%:");
554 wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
556 wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING));
557 mvwaddstrf(win_general, 0, 0, "Host pps ");
558 mvwaddstrf(win_general, 1, 0, "NICs pps ");
560 wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
561 mvwaddstrf(win_general, 0, 56, "avg");
562 mvwaddstrf(win_general, 1, 56, "avg");
563 wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
564 wattroff(win_general, A_BOLD);
566 wattron(win_general, A_BOLD);
567 wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING));
568 mvwaddstrf(win_general, 0, 9, "rx: tx: rx-tx: tx/rx: rx/tx:");
569 mvwaddstrf(win_general, 1, 9, "rx: tx: err: tx/rx: rx/tx:");
570 wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
572 wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
573 mvwaddstrf(win_general, 0, 0, "Host tot ");
574 mvwaddstrf(win_general, 1, 0, "NICs tot ");
575 wattroff(win_general, A_BOLD);
579 static void draw_status_bar(void)
581 wbkgd(win_help, COLOR_PAIR(BLACK_ON_WHITE));
583 mvwaddstrf(win_help, 0, 0,
584 "Enter 'help' or command, <ESC> or 'quit' to exit, "
585 "1-%zu to switch screens and 0 to reset stats, '=' to toggle between per-sec and total stats",
588 mvwin(win_help, LINES - 1, 0);
591 static void draw_log_window(void)
593 idlok(win_txt, FALSE);
595 scrollok(win_txt, TRUE);
597 /* Leave cursor where it was */
598 leaveok(win_txt, TRUE);
599 wbkgd(win_txt, COLOR_PAIR(BLACK_ON_CYAN));
603 static void stats_display_layout(uint8_t in_place)
605 uint8_t cur_stats_height;
607 cur_stats_height = current_screen->get_height();
608 cur_stats_height = cur_stats_height > max_n_lines? max_n_lines: cur_stats_height;
612 // moving existing windows does not work
625 win_stat = create_subwindow(cur_stats_height + 2, 0, 4, 0);
626 win_tabs = create_subwindow(1, 0, 1, 0);
627 win_general = create_subwindow(2, 0, 2, 0);
628 win_title = create_subwindow(1, 0, 0, 0);
629 win_cmd = create_subwindow(1, 0, cur_stats_height + 2 + 4, 0);
630 win_txt_height = LINES - cur_stats_height - 2 - 3 - 3;
631 win_txt = create_subwindow(win_txt_height, 0, cur_stats_height + 4 + 3, 0);
632 win_help = create_subwindow(1, 0, LINES - 1, 0);
636 draw_general_frame();
638 wbkgd(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW));
639 idlok(win_cmd, FALSE);
640 /* Move cursor at insertion point */
641 leaveok(win_cmd, FALSE);
646 /* Draw everything to the screen */
648 current_screen->draw_frame(&screen_state);
655 void display_end(void)
657 pthread_mutex_destroy(&disp_mtx);
664 static void pps_print(WINDOW *dst_scr, int y, int x, uint64_t val, int is_blue)
666 uint64_t rx_pps_disp = val;
667 uint64_t rx_pps_disp_frac = 0;
668 uint32_t ten_pow3 = 0;
669 static const char *units = " KMG";
672 while (rx_pps_disp > 1000) {
674 rx_pps_disp_frac = (val - rx_pps_disp*1000) / 10;
679 if (ten_pow3 >= strlen(units)) {
680 wbkgdset(dst_scr, COLOR_PAIR(RED_ON_NOTHING));
681 mvwaddstrf(dst_scr, y, x, "---");
682 wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
686 rx_unit = units[ten_pow3];
688 wattron(dst_scr, A_BOLD);
690 wbkgdset(dst_scr, COLOR_PAIR(BLUE_ON_NOTHING));
693 wbkgdset(dst_scr, COLOR_PAIR(CYAN_ON_NOTHING));
695 mvwaddstrf(dst_scr, y, x, "%3lu", rx_pps_disp);
696 if (rx_unit != ' ') {
697 mvwaddstrf(dst_scr, y, x + 3, ".%02lu", rx_pps_disp_frac);
698 wattroff(dst_scr, A_BOLD);
699 wbkgdset(dst_scr, COLOR_PAIR(WHITE_ON_NOTHING));
700 wattron(dst_scr, A_BOLD);
701 mvwaddstrf(dst_scr, y, x + 6, "%c", rx_unit);
702 wattroff(dst_scr, A_BOLD);
703 wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
706 mvwaddstrf(dst_scr, y, x + 3, " ");
708 wattroff(dst_scr, A_BOLD);
709 wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR));
712 static void display_stats_general_per_sec(void)
714 struct global_stats_sample *gsl = stats_get_global_stats(1);
715 struct global_stats_sample *gsp = stats_get_global_stats(0);
717 uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsp->host_rx_packets, gsl->tsc - gsp->tsc);
718 uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsp->host_tx_packets, gsl->tsc - gsp->tsc);
719 /* Host: RX, TX, Diff */
720 pps_print(win_general, 0, 12, rx_pps, 1);
721 pps_print(win_general, 0, 25, tx_pps, 1);
725 diff = rx_pps - tx_pps;
726 pps_print(win_general, 0, 40, diff, 1);
728 uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsp->nics_rx_packets, gsl->tsc - gsp->tsc);
729 uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsp->nics_tx_packets, gsl->tsc - gsp->tsc);
730 uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsp->nics_ierrors, gsl->tsc - gsp->tsc);
731 uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsp->nics_imissed, gsl->tsc - gsp->tsc);
733 /* NIC: RX, TX, Diff */
734 pps_print(win_general, 1, 12, nics_rx_pps, 1);
735 pps_print(win_general, 1, 25, nics_tx_pps, 1);
736 pps_print(win_general, 1, 40, nics_ierrors + nics_imissed, 1);
738 wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
739 wattron(win_general, A_BOLD);
740 mvwaddstrf(win_general, 0, 103, "%6.2f", tx_pps > rx_pps? 100 : tx_pps * 100.0 / rx_pps);
741 wattroff(win_general, A_BOLD);
742 wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
744 struct global_stats_sample *gsb = stats_get_global_stats_beg();
746 uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsb->host_rx_packets, gsl->tsc - gsb->tsc);
747 uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsb->host_tx_packets, gsl->tsc - gsb->tsc);
749 uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsb->nics_rx_packets, gsl->tsc - gsb->tsc);
750 uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsb->nics_tx_packets, gsl->tsc - gsb->tsc);
751 uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsb->nics_ierrors, gsl->tsc - gsb->tsc);
752 uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsb->nics_imissed, gsl->tsc - gsb->tsc);
754 pps_print(win_general, 0, 64, rx_pps, 0);
755 pps_print(win_general, 0, 77, tx_pps, 0);
757 pps_print(win_general, 1, 64, nics_rx_pps, 0);
758 pps_print(win_general, 1, 77, nics_tx_pps, 0);
759 pps_print(win_general, 1, 91, nics_ierrors + nics_imissed, 0);
761 wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING));
762 wattron(win_general, A_BOLD);
763 uint64_t nics_in = gsl->host_rx_packets - gsb->host_rx_packets + gsl->nics_ierrors - gsb->nics_ierrors + gsl->nics_imissed - gsb->nics_imissed;
764 uint64_t nics_out = gsl->host_tx_packets - gsb->host_tx_packets;
765 mvwaddstrf(win_general, 1, 103, "%6.2f", nics_out > nics_in?
766 100 : nics_out * 100.0 / nics_in);
767 wattron(win_general, A_BOLD);
768 wbkgdset(win_general, COLOR_PAIR(NO_COLOR));
772 static void display_stats_general_total(void)
774 struct global_stats_sample *gsl = stats_get_global_stats(1);
776 int64_t diff = (int64_t)gsl->host_rx_packets - gsl->host_tx_packets;
779 /* Host: RX, TX, Diff */
780 mvwaddstrf(win_general, 0, 13, "%16lu", gsl->host_rx_packets);
781 mvwaddstrf(win_general, 0, 35, "%16lu", gsl->host_tx_packets);
782 mvwaddstrf(win_general, 0, 60, "%16"PRId64"", diff);
783 if (gsl->host_rx_packets == 0)
786 percent = gsl->host_tx_packets * 1000000 / gsl->host_rx_packets;
787 mvwaddstrf(win_general, 0, 88, "%3u.%04u%%", percent / 10000, percent % 10000);
788 if (gsl->host_tx_packets == 0)
791 percent = gsl->host_rx_packets * 1000000 / gsl->host_tx_packets;
792 mvwaddstrf(win_general, 0, 106, "%3u.%04u%%", percent / 10000, percent % 10000);
794 mvwaddstrf(win_general, 1, 13, "%16lu", gsl->nics_rx_packets);
795 mvwaddstrf(win_general, 1, 35, "%16lu", gsl->nics_tx_packets);
796 mvwaddstrf(win_general, 1, 60, "%16lu", gsl->nics_ierrors + gsl->nics_imissed);
797 if (gsl->nics_rx_packets == 0)
800 percent = gsl->nics_tx_packets * 1000000 / gsl->nics_rx_packets;
801 mvwaddstrf(win_general, 1, 88, "%3u.%04u%%", percent / 10000, percent % 10000);
802 if (gsl->nics_tx_packets == 0)
805 percent = gsl->nics_rx_packets * 1000000 / gsl->nics_tx_packets;
806 mvwaddstrf(win_general, 1, 106, "%3u.%04u%%", percent / 10000, percent % 10000);
809 static void display_stats_general(void)
811 /* moment when stats were gathered. */
812 uint64_t cur_tsc = stats_get_last_tsc();
813 uint64_t up_time = tsc_to_sec(cur_tsc - stats_global_start_tsc());
814 uint64_t up_time2 = tsc_to_sec(cur_tsc - stats_global_beg_tsc());
815 uint64_t rem_time = -1;
816 char title_str[128] = {0};
818 if (stats_global_end_tsc()) {
819 uint64_t rem_tsc = stats_global_end_tsc() > cur_tsc? stats_global_end_tsc() - cur_tsc : 0;
821 rem_time = tsc_to_sec(rem_tsc);
824 if (up_time != up_time2 && cur_tsc >= stats_global_beg_tsc()) {
825 if (stats_global_end_tsc())
826 snprintf(title_str, sizeof(title_str), "%5lu (%lu) up, %lu rem", up_time, up_time2, rem_time);
828 snprintf(title_str, sizeof(title_str), "%5lu (%lu) up", up_time, up_time2);
831 if (stats_global_end_tsc())
832 snprintf(title_str, sizeof(title_str), "%5lu up, %lu rem", up_time, rem_time);
834 snprintf(title_str, sizeof(title_str), "%5lu up", up_time);
837 /* Only print up time information if there is enough space */
838 if ((int)((COLS + title_len)/2 + strlen(title_str) + 1) < COLS) {
839 mvwaddstrf(win_title, 0, COLS - strlen(title_str), "%s", title_str);
843 if (screen_state.toggle == 0)
844 display_stats_general_per_sec();
846 display_stats_general_total();
848 wrefresh(win_general);
851 char *print_time_unit_err_usec(char *dst, struct time_unit_err *t)
853 uint64_t nsec_total = time_unit_to_nsec(&t->time);
855 uint64_t usec = nsec_total/1000;
856 uint64_t nsec = nsec_total - usec*1000;
858 uint64_t nsec_total_error = time_unit_to_nsec(&t->error);
860 uint64_t usec_error = nsec_total_error/1000;
861 uint64_t nsec_error = nsec_total_error - usec_error*1000;
863 sprintf(dst, "%4"PRIu64".%03"PRIu64" +/- %2"PRIu64".%03"PRIu64"", usec, nsec, usec_error, nsec_error);
867 char *print_time_unit_usec(char *dst, struct time_unit *t)
869 uint64_t nsec_total = time_unit_to_nsec(t);
871 uint64_t usec = nsec_total/1000;
872 uint64_t nsec = nsec_total - usec*1000;
874 sprintf(dst, "%4"PRIu64".%03"PRIu64"", usec, nsec);
878 void toggle_display_screen(void)
880 screen_state.toggle = !screen_state.toggle;
881 stats_display_layout(0);
884 void display_screen(unsigned screen_id)
886 if (screen_id >= n_screens) {
887 plog_err("Unsupported screen %d\n", screen_id + 1);
891 if (screen_state.chosen_screen == screen_id) {
892 stats_display_layout(1);
895 screen_state.chosen_screen = screen_id;
896 current_screen = display_screens[screen_id];
897 stats_display_layout(0);
901 void display_page_up(void)
905 void display_page_down(void)
909 void display_refresh(void)
911 stats_display_layout(1);
914 void display_stats(void)
917 current_screen->draw_stats(&screen_state);
918 display_stats_general();
923 static char pages[32768] = {0};
924 static int cur_idx = 0;
925 static size_t pages_len = 0;
927 void display_print_page(void)
930 int cur_idx_prev = cur_idx;
932 if (cur_idx >= (int)pages_len) {
937 for (size_t i = cur_idx; i < pages_len; ++i) {
938 if (pages[i] == '\n') {
940 if (n_lines == win_txt_height - 2) {
948 waddstr(win_txt, pages + cur_idx_prev);
949 if (cur_idx != cur_idx_prev && cur_idx < (int)pages_len)
950 waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n");
958 void display_print(const char *str)
969 /* Check if the whole string can fit on the screen. */
970 pages_len = strlen(str);
972 memset(pages, 0, sizeof(pages));
973 memcpy(pages, str, pages_len);
975 for (size_t i = 0; i < pages_len; ++i) {
976 if (pages[i] == '\n') {
978 if (n_lines == win_txt_height - 2) {
986 waddstr(win_txt, pages);
988 waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n");