Merge "Add PCI to nova compute container for passthrough support" - apex-tripleo-heat-templates

diff options

author	Jenkins <jenkins@review.openstack.org>	2017-07-27 14:10:56 +0000
committer	Gerrit Code Review <review@openstack.org>	2017-07-27 14:10:57 +0000
commit	017f8b9b478e6e8a72cfb88cba54ce90b77e6532 (patch)
tree	57494b2d136aaa629307262b0176120e4f5a5a6d /puppet/services/swift-ringbuilder.yaml
parent	a8442ba386082cef7188c3ff8001f8995b1d7ff7 (diff)
parent	2168e7b15d7d5e7c438806ee399f699a012d3840 (diff)

Merge "Add PCI to nova compute container for passthrough support"

Diffstat (limited to 'puppet/services/swift-ringbuilder.yaml')

0 files changed, 0 insertions, 0 deletions

/* // Copyright (c) 2010-2019 Intel Corporation // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. */ #include <curses.h> #include <rte_cycles.h> #include <string.h> #include <signal.h> #include <math.h> #include <signal.h> #include "display_latency.h" #include "display_mempools.h" #include "display_ports.h" #include "display_priority.h" #include "display_irq.h" #include "display_latency_distr.h" #include "display_rings.h" #include "display_pkt_len.h" #include "display_l4gen.h" #include "display_tasks.h" #include "stats_irq.h" #include "stats_prio_task.h" #include "cqm.h" #include "msr.h" #include "display.h" #include "log.h" #include "commands.h" #include "main.h" #include "stats.h" #include "stats_port.h" #include "stats_latency.h" #include "stats_global.h" #include "stats_core.h" #include "prox_cfg.h" #include "prox_assert.h" #include "version.h" #include "quit.h" #include "prox_port_cfg.h" static struct screen_state screen_state = { .pps_unit = 1000, .chosen_screen = -1, }; static struct display_screen *display_screens[16]; static struct display_screen *current_screen; static size_t n_screens; static size_t longest_title; void display_set_pps_unit(int val) { screen_state.pps_unit = val; } /* Set up the display mutex as recursive. This enables threads to use display_[un]lock() to lock the display when multiple calls to for instance plog_info() need to be made. */ static pthread_mutex_t disp_mtx = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; static void stats_display_layout(uint8_t in_place); void display_lock(void) { pthread_mutex_lock(&disp_mtx); } void display_unlock(void) { pthread_mutex_unlock(&disp_mtx); } /* Advanced text output */ static WINDOW *scr = NULL, *win_txt, *win_general, *win_cmd, *win_stat, *win_title, *win_tabs, *win_help; static int win_txt_height = 1; static int title_len; static uint16_t max_n_lines; static int cmd_cursor_pos; static const char *cmd_cmd; static int cmd_len; /* Colors used in the interface */ enum colors { INVALID_COLOR, NO_COLOR, RED_ON_BLACK, BLACK_ON_CYAN, BLACK_ON_GREEN, BLACK_ON_WHITE, BLACK_ON_YELLOW, YELLOW_ON_BLACK, WHITE_ON_RED, YELLOW_ON_NOTHING, GREEN_ON_NOTHING, RED_ON_NOTHING, BLUE_ON_NOTHING, CYAN_ON_NOTHING, MAGENTA_ON_NOTHING, WHITE_ON_NOTHING, }; int display_getch(void) { int ret; display_lock(); ret = wgetch(scr); display_unlock(); return ret; } void display_cmd(const char *cmd, int cl, int cursor_pos) { cmd_len = cl; if (cursor_pos == -1 || cursor_pos > cmd_len) cursor_pos = cmd_len; cmd_cursor_pos = cursor_pos; cmd_cmd = cmd; display_lock(); werase(win_cmd); if (cursor_pos < cmd_len) { waddnstr(win_cmd, cmd, cursor_pos); wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK)); waddnstr(win_cmd, cmd + cursor_pos, 1); wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW)); waddnstr(win_cmd, cmd + cursor_pos + 1, cmd_len - (cursor_pos + 1)); } else { waddnstr(win_cmd, cmd, cmd_len); wmove(win_cmd, cursor_pos, 0); wbkgdset(win_cmd, COLOR_PAIR(YELLOW_ON_BLACK)); waddstr(win_cmd, " "); wbkgdset(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW)); } wattroff(win_stat, A_UNDERLINE); wrefresh(win_cmd); display_unlock(); } static void refresh_cmd_win(void) { display_cmd(cmd_cmd, cmd_len, cmd_cursor_pos); } static WINDOW *create_subwindow(int height, int width, int y_pos, int x_pos) { WINDOW *win = subwin(scr, height, width, y_pos, x_pos); touchwin(scr); return win; } /* The limit parameter sets the last column that something can be printed. If characters would be printed _past_ the limit, the last character printed within the limit will be a '~' to signify that the string cut off. The limit parameter will be ignored if its value is -1 */ static inline int mvwaddstrv(WINDOW *win, int y, int x, int limit, const char *fmt, va_list ap) { char buf[1024]; int ret; ret = vsnprintf(buf, sizeof(buf), fmt, ap); int len = ret; wmove(win, y, x); if (x > COLS - 1) { return 0; } /* To prevent strings from wrapping, cut the string at the end of the screen. */ if (x + len > COLS) { buf[COLS - 1 - x] = 0; len = COLS - x; } if (limit != -1 && x + len > limit) { int new_len = limit - x; if (new_len < 0) return 0; buf[new_len] = '~'; buf[new_len + 1] = 0; } waddstr(win, buf); return ret; } /* Format string capable [mv]waddstr() wrappers */ __attribute__((format(printf, 4, 5))) static inline int mvwaddstrf(WINDOW* win, int y, int x, const char *fmt, ...) { int ret; va_list ap; va_start(ap, fmt); ret = mvwaddstrv(win, y, x, -1, fmt, ap); va_end(ap); return ret; } __attribute__((format(printf, 5, 6))) static inline int mvwaddstrf_limit(WINDOW* win, int y, int x, int limit, const char *fmt, ...) { int ret; va_list ap; va_start(ap, fmt); ret = mvwaddstrv(win, y, x, limit, fmt, ap); va_end(ap); return ret; } // red: link down; Green: link up static short link_color(const uint8_t if_port) { return COLOR_PAIR(prox_port_cfg[if_port].link_up? GREEN_ON_NOTHING : RED_ON_NOTHING); } static void (*ncurses_sigwinch)(int); static void sigwinch(int in) { if (ncurses_sigwinch) ncurses_sigwinch(in); refresh(); stats_display_layout(0); } static void set_signal_handler(void) { struct sigaction old; sigaction(SIGWINCH, NULL, &old); ncurses_sigwinch = old.sa_handler; signal(SIGWINCH, sigwinch); } 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) { if (row >= max_n_lines) return; int pos = display_column->offset; int limit = pos + display_column->width; for (int i = 0; i < port_count && pos < limit; i++) { wbkgdset(win_stat, link_color(ports[i].port)); pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%u", ports[i].port); wbkgdset(win_stat, COLOR_PAIR(NO_COLOR)); if (i != port_count - 1) pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, " "); } for (uint8_t ring_id = 0; ring_id < ring_count && pos < limit; ++ring_id) { pos += mvwaddstrf_limit(win_stat, row + 2, pos, limit, "%s", rings[ring_id]->name); } } static void display_add_screen(struct display_screen *screen) { display_screens[n_screens++] = screen; if (longest_title < strlen(screen->title)) longest_title = strlen(screen->title); } static void display_init_screens(void) { if (n_screens) return; display_add_screen(display_tasks()); display_add_screen(display_ports()); display_add_screen(display_mempools()); display_add_screen(display_latency()); #ifdef LATENCY_HISTOGRAM display_add_screen(display_latency_distr()); #endif display_add_screen(display_rings()); display_add_screen(display_l4gen()); display_add_screen(display_pkt_len()); if (stats_get_n_prio_tasks_tot()) display_add_screen(display_priority()); if (stats_get_n_irq_tasks()) display_add_screen(display_irq()); } void display_init(void) { scr = initscr(); start_color(); /* Assign default foreground/background colors to color number -1 */ use_default_colors(); init_pair(NO_COLOR, -1, -1); init_pair(RED_ON_BLACK, COLOR_RED, COLOR_BLACK); init_pair(BLACK_ON_CYAN, COLOR_BLACK, COLOR_CYAN); init_pair(BLACK_ON_GREEN, COLOR_BLACK, COLOR_GREEN); init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE); init_pair(BLACK_ON_YELLOW, COLOR_BLACK, COLOR_YELLOW); init_pair(YELLOW_ON_BLACK, COLOR_YELLOW, COLOR_BLACK); init_pair(WHITE_ON_RED, COLOR_WHITE, COLOR_RED); init_pair(YELLOW_ON_NOTHING, COLOR_YELLOW, -1); init_pair(GREEN_ON_NOTHING, COLOR_GREEN, -1); init_pair(RED_ON_NOTHING, COLOR_RED, -1); init_pair(BLUE_ON_NOTHING, COLOR_BLUE, -1); init_pair(CYAN_ON_NOTHING, COLOR_CYAN, -1); init_pair(MAGENTA_ON_NOTHING, COLOR_MAGENTA, -1); init_pair(WHITE_ON_NOTHING, COLOR_WHITE, -1); /* nodelay(scr, TRUE); */ noecho(); curs_set(0); /* Create fullscreen log window. When stats are displayed later, it is recreated with appropriate dimensions. */ win_txt = create_subwindow(0, 0, 0, 0); wbkgd(win_txt, COLOR_PAIR(0)); idlok(win_txt, FALSE); /* Get scrolling */ scrollok(win_txt, TRUE); /* Leave cursor where it was */ leaveok(win_txt, TRUE); refresh(); set_signal_handler(); max_n_lines = (LINES - 5 - 2 - 3); /* core_port_height = max_n_lines < stats_get_n_tasks_tot()? max_n_lines : stats_get_n_tasks_tot(); */ display_init_screens(); display_screen(0); stats_display_layout(0); } static void display_page_recalc_offsets(struct display_page *display_page) { struct display_table *table; struct display_column *col; int total_offset = 0; for (int i = 0; i < display_page->n_tables; ++i) { table = &display_page->tables[i]; if (i != 0) total_offset += 1; table->offset = total_offset; for (int j = 0; j < table->n_cols; ++j) { col = &table->cols[j]; col->offset = total_offset; if (j + 1 != table->n_cols) total_offset += 1; total_offset += col->width; } table->width = total_offset - table->offset; } } void display_page_init(struct display_page *display_page) { struct display_table *table; struct display_column *col; int table_width = 0; int table_offset = 0; memset(display_page, 0, sizeof(*display_page)); display_page->n_tables = 0; for (size_t i = 0; i < sizeof(display_page->tables)/sizeof(display_page->tables[0]); ++i) { table = &display_page->tables[i]; for (size_t j = 0; j < sizeof(table->cols)/sizeof(table->cols[0]); ++j) { col = &table->cols[j]; col->display_page = display_page; } } } struct display_table *display_page_add_table(struct display_page *display_page) { struct display_table *table = &display_page->tables[display_page->n_tables]; display_page->n_tables++; return table; } void display_table_init(struct display_table *table, const char *title) { strcpy(table->title, title); table->n_cols = 0; } struct display_column *display_table_add_col(struct display_table *table) { struct display_column *col = &table->cols[table->n_cols]; table->n_cols++; return col; } void display_column_init(struct display_column *display_column, const char *title, unsigned width) { if (width < strlen(title)) width = strlen(title); strcpy(display_column->title, title); display_column->width = width; display_page_recalc_offsets(display_column->display_page); } int display_column_get_width(const struct display_column *display_column) { return display_column->width; } void display_page_draw_frame(const struct display_page *display_page, int height) { const struct display_table *table; const struct display_column *col; wattron(win_stat, A_BOLD); wbkgdset(win_stat, COLOR_PAIR(YELLOW_ON_NOTHING)); for (int i = 0; i < display_page->n_tables; ++i) { table = &display_page->tables[i]; if (i != 0) mvwvline(win_stat, 0, table->offset - 1, ACS_VLINE, height + 2); mvwaddstrf(win_stat, 0, table->offset + table->width / 2 - strlen(table->title) / 2, "%s", table->title); for (int j = 0; j < table->n_cols; ++j) { col = &table->cols[j]; if (j != 0) mvwvline(win_stat, 1, col->offset - 1, ACS_VLINE, height + 1); mvwaddstrf(win_stat, 1, col->offset + col->width / 2 - strlen(col->title) / 2, "%s", col->title); } if (i + 1 == display_page->n_tables) mvwvline(win_stat, 0, table->offset + table->width, ACS_VLINE, height + 2); } wbkgdset(win_stat, COLOR_PAIR(NO_COLOR)); wattroff(win_stat, A_BOLD); } void display_column_print(const struct display_column *display_column, int row, const char *fmt, ...) { if (row >= max_n_lines) return; va_list ap; char buffer[128] = {0}; char *to_print = buffer + 64; va_start(ap, fmt); int len = vsnprintf(to_print, sizeof(buffer) - 64, fmt, ap); va_end(ap); int offset = 0; /* If column is too long, add ~ at the end. If it is too short, align on the right. */ if (len > display_column->width) { to_print[display_column->width - 1] = '~'; to_print[display_column->width] = '\0'; } else { int diff = display_column->width - len; to_print += len; to_print -= display_column->width; for (int i = 0; i < diff; i++) to_print[i] = ' '; } mvwaddstrf(win_stat, row + 2, display_column->offset, "%s", to_print); } void display_column_print_core_task(const struct display_column *display_column, int row, struct lcore_cfg *lconf, struct task_args *targ) { if (row >= max_n_lines) return; if (lconf->n_tasks_run == 0) { wattron(win_stat, A_BOLD); wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING)); } if (targ->id == 0) mvwaddstrf(win_stat, row + 2, display_column->offset, "%2u/", lconf->id); if (lconf->n_tasks_run == 0) { wattroff(win_stat, A_BOLD); wbkgdset(win_stat, COLOR_PAIR(NO_COLOR)); } if (!lconf_task_is_running(lconf, targ->id)) { wattron(win_stat, A_BOLD); wbkgdset(win_stat, COLOR_PAIR(RED_ON_NOTHING)); } mvwaddstrf(win_stat, row + 2, display_column->offset + 3, "%1u", targ->id); if (!lconf_task_is_running(lconf, targ->id)) { wattroff(win_stat, A_BOLD); wbkgdset(win_stat, COLOR_PAIR(NO_COLOR)); } } static void redraw_tabs(unsigned screen_id) { const size_t len = longest_title + 1; for (size_t i = 0; i < n_screens; ++i) { if (i == screen_id) wbkgdset(win_tabs, COLOR_PAIR(BLACK_ON_GREEN)); mvwaddstrf(win_tabs, 0, i*(len + 3), "%zu ", i+1); if (i != screen_id) wbkgdset(win_tabs, COLOR_PAIR(GREEN_ON_NOTHING)); mvwaddstrf(win_tabs, 0, i*(len + 3) + 2, "%s", display_screens[i]->title); for (size_t j = strlen(display_screens[i]->title); j < len - 1; ++j) mvwaddstrf(win_tabs, 0, i*(len + 3) + 2 + j, " "); if (i != screen_id) wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR)); if (i == screen_id) wbkgdset(win_tabs, COLOR_PAIR(NO_COLOR)); } wrefresh(win_tabs); } static void draw_title(void) { char title_str[128]; snprintf(title_str, sizeof(title_str), "%s %s: %s", PROGRAM_NAME, VERSION_STR(), prox_cfg.name); wbkgd(win_title, COLOR_PAIR(BLACK_ON_GREEN)); title_len = strlen(title_str); mvwaddstrf(win_title, 0, (COLS - title_len)/2, "%s", title_str); redraw_tabs(screen_state.chosen_screen); } static void draw_general_frame(void) { if (screen_state.toggle == 0) { wattron(win_general, A_BOLD); wbkgdset(win_general, COLOR_PAIR(MAGENTA_ON_NOTHING)); mvwaddstrf(win_general, 0, 9, "rx: tx: diff: rx: tx: %%:"); mvwaddstrf(win_general, 1, 9, "rx: tx: err: rx: tx: err: %%:"); wbkgdset(win_general, COLOR_PAIR(NO_COLOR)); wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING)); mvwaddstrf(win_general, 0, 0, "Host pps "); mvwaddstrf(win_general, 1, 0, "NICs pps "); wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING)); mvwaddstrf(win_general, 0, 56, "avg"); mvwaddstrf(win_general, 1, 56, "avg"); wbkgdset(win_general, COLOR_PAIR(NO_COLOR)); wattroff(win_general, A_BOLD); } else { wattron(win_general, A_BOLD); wbkgdset(win_general, COLOR_PAIR(BLUE_ON_NOTHING)); mvwaddstrf(win_general, 0, 9, "rx: tx: rx-tx: tx/rx: rx/tx:"); mvwaddstrf(win_general, 1, 9, "rx: tx: err: tx/rx: rx/tx:"); wbkgdset(win_general, COLOR_PAIR(NO_COLOR)); wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING)); mvwaddstrf(win_general, 0, 0, "Host tot "); mvwaddstrf(win_general, 1, 0, "NICs tot "); wattroff(win_general, A_BOLD); } } static void draw_status_bar(void) { wbkgd(win_help, COLOR_PAIR(BLACK_ON_WHITE)); werase(win_help); mvwaddstrf(win_help, 0, 0, "Enter 'help' or command, <ESC> or 'quit' to exit, " "1-%zu to switch screens and 0 to reset stats, '=' to toggle between per-sec and total stats", n_screens); wrefresh(win_help); mvwin(win_help, LINES - 1, 0); } static void draw_log_window(void) { idlok(win_txt, FALSE); /* Get scrolling */ scrollok(win_txt, TRUE); /* Leave cursor where it was */ leaveok(win_txt, TRUE); wbkgd(win_txt, COLOR_PAIR(BLACK_ON_CYAN)); wrefresh(win_txt); } static void stats_display_layout(uint8_t in_place) { uint8_t cur_stats_height; cur_stats_height = current_screen->get_height(); cur_stats_height = cur_stats_height > max_n_lines? max_n_lines: cur_stats_height; display_lock(); if (!in_place) { // moving existing windows does not work delwin(win_txt); delwin(win_general); delwin(win_title); delwin(win_tabs); delwin(win_cmd); delwin(win_txt); delwin(win_help); clear(); } if (!in_place) { win_stat = create_subwindow(cur_stats_height + 2, 0, 4, 0); win_tabs = create_subwindow(1, 0, 1, 0); win_general = create_subwindow(2, 0, 2, 0); win_title = create_subwindow(1, 0, 0, 0); win_cmd = create_subwindow(1, 0, cur_stats_height + 2 + 4, 0); win_txt_height = LINES - cur_stats_height - 2 - 3 - 3; win_txt = create_subwindow(win_txt_height, 0, cur_stats_height + 4 + 3, 0); win_help = create_subwindow(1, 0, LINES - 1, 0); } draw_title(); draw_general_frame(); /* Command line */ wbkgd(win_cmd, COLOR_PAIR(BLACK_ON_YELLOW)); idlok(win_cmd, FALSE); /* Move cursor at insertion point */ leaveok(win_cmd, FALSE); draw_status_bar(); draw_log_window(); /* Draw everything to the screen */ refresh(); current_screen->draw_frame(&screen_state); display_unlock(); refresh_cmd_win(); display_stats(); } void display_end(void) { pthread_mutex_destroy(&disp_mtx); if (scr != NULL) { endwin(); } scr = NULL; } static void pps_print(WINDOW *dst_scr, int y, int x, uint64_t val, int is_blue) { uint64_t rx_pps_disp = val; uint64_t rx_pps_disp_frac = 0; uint32_t ten_pow3 = 0; static const char *units = " KMG"; char rx_unit = ' '; while (rx_pps_disp > 1000) { rx_pps_disp /= 1000; rx_pps_disp_frac = (val - rx_pps_disp*1000) / 10; val /= 1000; ten_pow3++; } if (ten_pow3 >= strlen(units)) { wbkgdset(dst_scr, COLOR_PAIR(RED_ON_NOTHING)); mvwaddstrf(dst_scr, y, x, "---"); wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR)); return; } rx_unit = units[ten_pow3]; wattron(dst_scr, A_BOLD); if (is_blue) { wbkgdset(dst_scr, COLOR_PAIR(BLUE_ON_NOTHING)); } else wbkgdset(dst_scr, COLOR_PAIR(CYAN_ON_NOTHING)); mvwaddstrf(dst_scr, y, x, "%3lu", rx_pps_disp); if (rx_unit != ' ') { mvwaddstrf(dst_scr, y, x + 3, ".%02lu", rx_pps_disp_frac); wattroff(dst_scr, A_BOLD); wbkgdset(dst_scr, COLOR_PAIR(WHITE_ON_NOTHING)); wattron(dst_scr, A_BOLD); mvwaddstrf(dst_scr, y, x + 6, "%c", rx_unit); wattroff(dst_scr, A_BOLD); wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR)); } else { mvwaddstrf(dst_scr, y, x + 3, " "); } wattroff(dst_scr, A_BOLD); wbkgdset(dst_scr, COLOR_PAIR(NO_COLOR)); } static void display_stats_general_per_sec(void) { struct global_stats_sample *gsl = stats_get_global_stats(1); struct global_stats_sample *gsp = stats_get_global_stats(0); uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsp->host_rx_packets, gsl->tsc - gsp->tsc); uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsp->host_tx_packets, gsl->tsc - gsp->tsc); /* Host: RX, TX, Diff */ pps_print(win_general, 0, 12, rx_pps, 1); pps_print(win_general, 0, 25, tx_pps, 1); uint64_t diff = 0; if (rx_pps > tx_pps) diff = rx_pps - tx_pps; pps_print(win_general, 0, 40, diff, 1); uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsp->nics_rx_packets, gsl->tsc - gsp->tsc); uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsp->nics_tx_packets, gsl->tsc - gsp->tsc); uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsp->nics_ierrors, gsl->tsc - gsp->tsc); uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsp->nics_imissed, gsl->tsc - gsp->tsc); /* NIC: RX, TX, Diff */ pps_print(win_general, 1, 12, nics_rx_pps, 1); pps_print(win_general, 1, 25, nics_tx_pps, 1); pps_print(win_general, 1, 40, nics_ierrors + nics_imissed, 1); wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING)); wattron(win_general, A_BOLD); mvwaddstrf(win_general, 0, 103, "%6.2f", tx_pps > rx_pps? 100 : tx_pps * 100.0 / rx_pps); wattroff(win_general, A_BOLD); wbkgdset(win_general, COLOR_PAIR(NO_COLOR)); struct global_stats_sample *gsb = stats_get_global_stats_beg(); if (gsb) { uint64_t rx_pps = val_to_rate(gsl->host_rx_packets - gsb->host_rx_packets, gsl->tsc - gsb->tsc); uint64_t tx_pps = val_to_rate(gsl->host_tx_packets - gsb->host_tx_packets, gsl->tsc - gsb->tsc); uint64_t nics_rx_pps = val_to_rate(gsl->nics_rx_packets - gsb->nics_rx_packets, gsl->tsc - gsb->tsc); uint64_t nics_tx_pps = val_to_rate(gsl->nics_tx_packets - gsb->nics_tx_packets, gsl->tsc - gsb->tsc); uint64_t nics_ierrors = val_to_rate(gsl->nics_ierrors - gsb->nics_ierrors, gsl->tsc - gsb->tsc); uint64_t nics_imissed = val_to_rate(gsl->nics_imissed - gsb->nics_imissed, gsl->tsc - gsb->tsc); pps_print(win_general, 0, 64, rx_pps, 0); pps_print(win_general, 0, 77, tx_pps, 0); pps_print(win_general, 1, 64, nics_rx_pps, 0); pps_print(win_general, 1, 77, nics_tx_pps, 0); pps_print(win_general, 1, 91, nics_ierrors + nics_imissed, 0); wbkgdset(win_general, COLOR_PAIR(CYAN_ON_NOTHING)); wattron(win_general, A_BOLD); uint64_t nics_in = gsl->host_rx_packets - gsb->host_rx_packets + gsl->nics_ierrors - gsb->nics_ierrors + gsl->nics_imissed - gsb->nics_imissed; uint64_t nics_out = gsl->host_tx_packets - gsb->host_tx_packets; mvwaddstrf(win_general, 1, 103, "%6.2f", nics_out > nics_in? 100 : nics_out * 100.0 / nics_in); wattron(win_general, A_BOLD); wbkgdset(win_general, COLOR_PAIR(NO_COLOR)); } } static void display_stats_general_total(void) { struct global_stats_sample *gsl = stats_get_global_stats(1); int64_t diff = (int64_t)gsl->host_rx_packets - gsl->host_tx_packets; uint32_t percent; /* Host: RX, TX, Diff */ mvwaddstrf(win_general, 0, 13, "%16lu", gsl->host_rx_packets); mvwaddstrf(win_general, 0, 35, "%16lu", gsl->host_tx_packets); mvwaddstrf(win_general, 0, 60, "%16"PRId64"", diff); if (gsl->host_rx_packets == 0) percent = 1000000; else percent = gsl->host_tx_packets * 1000000 / gsl->host_rx_packets; mvwaddstrf(win_general, 0, 88, "%3u.%04u%%", percent / 10000, percent % 10000); if (gsl->host_tx_packets == 0) percent = 1000000; else percent = gsl->host_rx_packets * 1000000 / gsl->host_tx_packets; mvwaddstrf(win_general, 0, 106, "%3u.%04u%%", percent / 10000, percent % 10000); mvwaddstrf(win_general, 1, 13, "%16lu", gsl->nics_rx_packets); mvwaddstrf(win_general, 1, 35, "%16lu", gsl->nics_tx_packets); mvwaddstrf(win_general, 1, 60, "%16lu", gsl->nics_ierrors + gsl->nics_imissed); if (gsl->nics_rx_packets == 0) percent = 1000000; else percent = gsl->nics_tx_packets * 1000000 / gsl->nics_rx_packets; mvwaddstrf(win_general, 1, 88, "%3u.%04u%%", percent / 10000, percent % 10000); if (gsl->nics_tx_packets == 0) percent = 1000000; else percent = gsl->nics_rx_packets * 1000000 / gsl->nics_tx_packets; mvwaddstrf(win_general, 1, 106, "%3u.%04u%%", percent / 10000, percent % 10000); } static void display_stats_general(void) { /* moment when stats were gathered. */ uint64_t cur_tsc = stats_get_last_tsc(); uint64_t up_time = tsc_to_sec(cur_tsc - stats_global_start_tsc()); uint64_t up_time2 = tsc_to_sec(cur_tsc - stats_global_beg_tsc()); uint64_t rem_time = -1; char title_str[128] = {0}; if (stats_global_end_tsc()) { uint64_t rem_tsc = stats_global_end_tsc() > cur_tsc? stats_global_end_tsc() - cur_tsc : 0; rem_time = tsc_to_sec(rem_tsc); } if (up_time != up_time2 && cur_tsc >= stats_global_beg_tsc()) { if (stats_global_end_tsc()) snprintf(title_str, sizeof(title_str), "%5lu (%lu) up, %lu rem", up_time, up_time2, rem_time); else snprintf(title_str, sizeof(title_str), "%5lu (%lu) up", up_time, up_time2); } else { if (stats_global_end_tsc()) snprintf(title_str, sizeof(title_str), "%5lu up, %lu rem", up_time, rem_time); else snprintf(title_str, sizeof(title_str), "%5lu up", up_time); } /* Only print up time information if there is enough space */ if ((int)((COLS + title_len)/2 + strlen(title_str) + 1) < COLS) { mvwaddstrf(win_title, 0, COLS - strlen(title_str), "%s", title_str); wrefresh(win_title); } if (screen_state.toggle == 0) display_stats_general_per_sec(); else display_stats_general_total(); wrefresh(win_general); } char *print_time_unit_err_usec(char *dst, struct time_unit_err *t) { uint64_t nsec_total = time_unit_to_nsec(&t->time); uint64_t usec = nsec_total/1000; uint64_t nsec = nsec_total - usec*1000; uint64_t nsec_total_error = time_unit_to_nsec(&t->error); uint64_t usec_error = nsec_total_error/1000; uint64_t nsec_error = nsec_total_error - usec_error*1000; sprintf(dst, "%4"PRIu64".%03"PRIu64" +/- %2"PRIu64".%03"PRIu64"", usec, nsec, usec_error, nsec_error); return dst; } char *print_time_unit_usec(char *dst, struct time_unit *t) { uint64_t nsec_total = time_unit_to_nsec(t); uint64_t usec = nsec_total/1000; uint64_t nsec = nsec_total - usec*1000; sprintf(dst, "%4"PRIu64".%03"PRIu64"", usec, nsec); return dst; } void toggle_display_screen(void) { screen_state.toggle = !screen_state.toggle; stats_display_layout(0); } void display_screen(unsigned screen_id) { if (screen_id >= n_screens) { plog_err("Unsupported screen %d\n", screen_id + 1); return; } if (screen_state.chosen_screen == screen_id) { stats_display_layout(1); } else { screen_state.chosen_screen = screen_id; current_screen = display_screens[screen_id]; stats_display_layout(0); } } void display_page_up(void) { } void display_page_down(void) { } void display_refresh(void) { stats_display_layout(1); } void display_renew(void) { stats_display_layout(0); } void display_stats(void) { display_lock(); current_screen->draw_stats(&screen_state); display_stats_general(); wrefresh(win_stat); display_unlock(); } static char pages[32768] = {0}; static int cur_idx = 0; static size_t pages_len = 0; void display_print_page(void) { int n_lines = 0; int cur_idx_prev = cur_idx; if (cur_idx >= (int)pages_len) { return; } display_lock(); for (size_t i = cur_idx; i < pages_len; ++i) { if (pages[i] == '\n') { n_lines++; if (n_lines == win_txt_height - 2) { pages[i] = 0; cur_idx = i + 1; break; } } } waddstr(win_txt, pages + cur_idx_prev); if (cur_idx != cur_idx_prev && cur_idx < (int)pages_len) waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n"); else { pages_len = 0; } wrefresh(win_txt); display_unlock(); } void display_print(const char *str) { display_lock(); if (scr == NULL) { fputs(str, stdout); fflush(stdout); display_unlock(); return; } /* Check if the whole string can fit on the screen. */ pages_len = strlen(str); int n_lines = 0; memset(pages, 0, sizeof(pages)); memcpy(pages, str, pages_len); cur_idx = 0; for (size_t i = 0; i < pages_len; ++i) { if (pages[i] == '\n') { n_lines++; if (n_lines == win_txt_height - 2) { pages[i] = 0; cur_idx = i + 1; break; } } } waddstr(win_txt, pages); if (cur_idx != 0) waddstr(win_txt, "\nPRESS ENTER FOR MORE...\n"); else pages_len = 0; wrefresh(win_txt); display_unlock(); }


context:
space:
mode: