Fix toeplitz initialization key and rss key len for mlx4
[samplevnf.git] / VNFs / DPPD-PROX / display_ports.c
1 /*
2 // Copyright (c) 2010-2017 Intel Corporation
3 //
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
7 //
8 //     http://www.apache.org/licenses/LICENSE-2.0
9 //
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.
15 */
16
17 #include <rte_cycles.h>
18
19 #include "clock.h"
20 #include "display_ports.h"
21 #include "display.h"
22 #include "stats_port.h"
23 #include "prox_globals.h"
24 #include "prox_port_cfg.h"
25 #include "prox_compat.h"
26
27 static struct display_page display_page_ports;
28 static struct display_column *nb_col;
29 static struct display_column *name_col;
30 static struct display_column *type_col;
31
32 static struct display_column *no_mbufs_col;
33 static struct display_column *ierrors_col;
34 static struct display_column *imissed_col;
35 static struct display_column *oerrors_col;
36 static struct display_column *rx_col;
37 static struct display_column *tx_col;
38 static struct display_column *rx_bytes_col;
39 static struct display_column *tx_bytes_col;
40 static struct display_column *rx_percent_col;
41 static struct display_column *tx_percent_col;
42
43 static int port_disp[PROX_MAX_PORTS];
44 static int n_port_disp;
45
46 static void display_ports_draw_frame(struct screen_state *state)
47 {
48         n_port_disp = 0;
49         for (uint8_t i = 0; i < PROX_MAX_PORTS; ++i) {
50                 if (prox_port_cfg[i].active) {
51                         port_disp[n_port_disp++] = i;
52                 }
53         }
54
55         const uint32_t n_ports = stats_get_n_ports();
56         char name[32];
57         char *ptr;
58
59         display_page_init(&display_page_ports);
60
61         struct display_table *port = display_page_add_table(&display_page_ports);
62         struct display_table *stats = display_page_add_table(&display_page_ports);
63
64         display_table_init(port, "Port");
65
66         nb_col = display_table_add_col(port);
67         name_col = display_table_add_col(port);
68         type_col = display_table_add_col(port);
69
70         display_column_init(nb_col, "Nb", 4);
71         display_column_init(name_col, "Name", 8);
72         display_column_init(type_col, "Type", 7);
73
74         if (state->toggle == 0) {
75                 display_table_init(stats, "Statistics per second");
76                 no_mbufs_col = display_table_add_col(stats);
77                 ierrors_col = display_table_add_col(stats);
78                 imissed_col = display_table_add_col(stats);
79                 oerrors_col = display_table_add_col(stats);
80                 rx_col = display_table_add_col(stats);
81                 tx_col = display_table_add_col(stats);
82                 rx_bytes_col = display_table_add_col(stats);
83                 tx_bytes_col = display_table_add_col(stats);
84                 rx_percent_col = display_table_add_col(stats);
85                 tx_percent_col = display_table_add_col(stats);
86
87                 display_column_init(no_mbufs_col, "no mbufs (#)", 12);
88                 display_column_init(ierrors_col, "ierrors (#)", 12);
89                 display_column_init(imissed_col, "imissed (#)", 12);
90                 display_column_init(oerrors_col, "oerrors (#)", 12);
91                 display_column_init(rx_col, "RX (Kpps)", 10);
92                 display_column_init(tx_col, "TX (Kpps)", 10);
93                 display_column_init(rx_bytes_col, "RX (Kbps)", 10);
94                 display_column_init(tx_bytes_col, "TX (Kbps)", 10);
95                 display_column_init(rx_percent_col, "RX (%)", 8);
96                 display_column_init(tx_percent_col, "TX (%)", 8);
97         } else {
98                 display_table_init(stats, "Total statistics");
99                 no_mbufs_col = display_table_add_col(stats);
100                 ierrors_col = display_table_add_col(stats);
101                 imissed_col = display_table_add_col(stats);
102                 oerrors_col = display_table_add_col(stats);
103                 rx_col = display_table_add_col(stats);
104                 tx_col = display_table_add_col(stats);
105
106                 display_column_init(no_mbufs_col, "no mbufs (#)", 13);
107                 display_column_init(ierrors_col, "ierrors (#)", 13);
108                 display_column_init(imissed_col, "imissed (#)", 13);
109                 display_column_init(oerrors_col, "oerrors (#)", 13);
110                 display_column_init(rx_col, "RX (#)", 13);
111                 display_column_init(tx_col, "TX (#)", 13);
112         }
113
114         display_page_draw_frame(&display_page_ports, n_port_disp);
115         for (uint8_t i = 0; i < n_port_disp; ++i) {
116                 const uint32_t port_id = port_disp[i];
117
118                 display_column_print(nb_col, i, "%u", port_id);
119                 display_column_print(name_col, i, "%s", prox_port_cfg[port_id].names[0]);
120                 display_column_print(type_col, i, "%s", prox_port_cfg[port_id].short_name);
121         }
122 }
123
124 struct percent {
125         uint32_t percent;
126         uint32_t part;
127 };
128
129 static struct percent calc_percent(uint64_t val, uint64_t delta_t)
130 {
131         struct percent ret;
132         uint64_t normalized = 0;
133
134         if (val == 0) {
135                 ret.percent = 0;
136                 ret.part = 0;
137         } else if (val < thresh) {
138                 ret.percent = val * tsc_hz / delta_t / 12500000;
139                 ret.part = (val * tsc_hz / delta_t / 1250) % 10000;
140         } else if (delta_t > tsc_hz) {
141                 ret.percent = val / (delta_t / tsc_hz) / 12500000;
142                 ret.part = (val / (delta_t / tsc_hz) / 1250) % 10000;
143         } else {
144                 ret.percent = 0;
145                 ret.part = 0;
146         }
147         return ret;
148 }
149
150 static void display_ports_draw_per_sec_stats(void)
151 {
152         for (uint8_t i = 0; i < n_port_disp; ++i) {
153                 const uint32_t port_id = port_disp[i];
154                 struct port_stats_sample *last = stats_get_port_stats_sample(port_id, 1);
155                 struct port_stats_sample *prev = stats_get_port_stats_sample(port_id, 0);
156
157                 uint64_t delta_t = last->tsc - prev->tsc;
158
159                 /* This could happen if we just reset the screen.
160                    stats will be updated later */
161                 if (delta_t == 0)
162                         continue;
163
164                 uint64_t no_mbufs_rate = val_to_rate(last->no_mbufs - prev->no_mbufs, delta_t);
165                 uint64_t ierrors_rate = val_to_rate(last->ierrors - prev->ierrors, delta_t);
166                 uint64_t imissed_rate = val_to_rate(last->imissed - prev->imissed, delta_t);
167                 uint64_t oerrors_rate = val_to_rate(last->oerrors - prev->oerrors, delta_t);
168
169                 uint64_t rx_kbps_rate = val_to_rate((last->rx_bytes - prev->rx_bytes) * 8, delta_t) / 1000;
170                 uint64_t tx_kbps_rate = val_to_rate((last->tx_bytes - prev->tx_bytes) * 8, delta_t) / 1000;
171
172                 uint64_t rx_rate = val_to_rate(last->rx_tot - prev->rx_tot, delta_t) / 1000;
173                 if (unlikely(prev->rx_tot > last->rx_tot))
174                         rx_rate = 0;
175                 uint64_t tx_rate = val_to_rate(last->tx_tot - prev->tx_tot, delta_t) / 1000;
176                 if (unlikely(prev->tx_tot > last->tx_tot))
177                         tx_rate = 0;
178
179                 /* Take 20 bytes overhead (or 24 if crc strip is enabled) into accound */
180                 struct percent rx_percent;
181                 struct percent tx_percent;
182                 if (strcmp(prox_port_cfg[port_id].short_name, "i40e_vf") == 0) {
183 #if defined (DEV_RX_OFFLOAD_CRC_STRIP)
184                         if (prox_port_cfg[port_id].requested_rx_offload & DEV_RX_OFFLOAD_CRC_STRIP) {
185                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
186                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
187                         } else {
188                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
189                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
190                         }
191                 } else {
192                         if (prox_port_cfg[port_id].requested_rx_offload & DEV_RX_OFFLOAD_CRC_STRIP) {
193                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 24 * (last->rx_tot - prev->rx_tot), delta_t);
194                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
195                         } else {
196                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
197                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
198                         }
199                 }
200 #else
201 #if defined DEV_RX_OFFLOAD_KEEP_CRC
202                         if (prox_port_cfg[port_id].requested_rx_offload & DEV_RX_OFFLOAD_KEEP_CRC ) {
203                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
204                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
205                         } else {
206                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
207                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
208                         }
209                 } else {
210                         if (prox_port_cfg[port_id].requested_rx_offload & DEV_RX_OFFLOAD_KEEP_CRC ) {
211                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 20 * (last->rx_tot - prev->rx_tot), delta_t);
212                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 20 * (last->tx_tot - prev->tx_tot), delta_t);
213                         } else {
214                                 rx_percent = calc_percent(last->rx_bytes - prev->rx_bytes + 24 * (last->rx_tot - prev->rx_tot), delta_t);
215                                 tx_percent = calc_percent(last->tx_bytes - prev->tx_bytes + 24 * (last->tx_tot - prev->tx_tot), delta_t);
216                         }
217                 }
218 #else
219 #error neither DEV_RX_OFFLOAD_CRC_STRIP or DEV_RX_OFFLOAD_KEEP_CRC is defined
220 #endif
221 #endif
222
223                 display_column_print(no_mbufs_col, i, "%lu", no_mbufs_rate);
224                 display_column_print(ierrors_col, i, "%lu", ierrors_rate);
225                 display_column_print(imissed_col, i, "%lu", imissed_rate);
226                 display_column_print(oerrors_col, i, "%lu", oerrors_rate);
227
228                 display_column_print(rx_bytes_col, i, "%lu", rx_kbps_rate);
229                 display_column_print(tx_bytes_col, i, "%lu", tx_kbps_rate);
230                 display_column_print(rx_col, i, "%lu", rx_rate);
231                 display_column_print(tx_col, i, "%lu", tx_rate);
232
233                 display_column_print(rx_percent_col, i, "%3u.%04u", rx_percent.percent, rx_percent.part);
234                 display_column_print(tx_percent_col, i, "%3u.%04u", tx_percent.percent, tx_percent.part);
235         }
236 }
237
238 static void display_ports_draw_total_stats(void)
239 {
240         for (uint8_t i = 0; i < n_port_disp; ++i) {
241                 const uint32_t port_id = port_disp[i];
242                 struct port_stats_sample *last = stats_get_port_stats_sample(port_id, 1);
243
244                 display_column_print(no_mbufs_col, i, "%lu", last->no_mbufs);
245                 display_column_print(ierrors_col, i, "%lu", last->ierrors);
246                 display_column_print(imissed_col, i, "%lu", last->imissed);
247                 display_column_print(oerrors_col, i, "%lu", last->oerrors);
248                 display_column_print(rx_col, i, "%lu", last->rx_tot);
249                 display_column_print(tx_col, i, "%lu", last->tx_tot);
250         }
251 }
252
253 static void display_ports_draw_stats(struct screen_state *state)
254 {
255         if (state->toggle == 0)
256                 display_ports_draw_per_sec_stats();
257         else
258                 display_ports_draw_total_stats();
259 }
260
261 static int display_ports_get_height(void)
262 {
263         return stats_get_n_ports();
264 }
265
266 static struct display_screen display_screen_ports = {
267         .draw_frame = display_ports_draw_frame,
268         .draw_stats = display_ports_draw_stats,
269         .get_height = display_ports_get_height,
270         .title = "ports",
271 };
272
273 struct display_screen *display_ports(void)
274 {
275         return &display_screen_ports;
276 }