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.
17 #include "display_tasks.h"
19 #include "prox_globals.h"
20 #include "stats_task.h"
21 #include "stats_core.h"
24 struct task_stats_disp {
27 uint32_t lcore_stat_id;
30 static int col_offset;
31 static struct task_stats_disp task_stats_disp[RTE_MAX_LCORE * MAX_TASKS_PER_CORE];
33 static struct display_page display_page_tasks;
35 static struct display_column *nb_col;
36 static struct display_column *name_col;
37 static struct display_column *mode_col;
38 static struct display_column *rx_name_col;
39 static struct display_column *tx_name_col;
40 static struct display_column *idle_col;
41 static struct display_column *rx_col;
42 static struct display_column *tx_col;
43 static struct display_column *tx_fail_col;
44 static struct display_column *discard_col;
45 static struct display_column *handled_col;
46 static struct display_column *cpp_col;
47 static struct display_column *ghz_col;
48 static struct display_column *rx_col;
49 static struct display_column *tx_col;
50 static struct display_column *tx_fail_col;
51 static struct display_column *discard_col;
52 static struct display_column *handled_col;
53 static struct display_column *occup_col;
54 static struct display_column *mask_col;
55 static struct display_column *class_col;
56 static struct display_column *mbm_tot_col;
57 static struct display_column *mbm_loc_col;
58 static struct display_column *frac_col;
60 static void stats_display_core_task_entry(struct lcore_cfg *lconf, struct task_args *targ, unsigned row)
62 display_column_print_core_task(nb_col, row, lconf, targ);
64 display_column_print(name_col, row, "%s", targ->id == 0 ? lconf->name : "");
65 display_column_print(mode_col, row, "%s", targ->task_init->mode_str);
67 display_column_port_ring(rx_name_col, row, targ->rx_port_queue, targ->nb_rxports, targ->rx_rings, targ->nb_rxrings);
68 display_column_port_ring(tx_name_col, row, targ->tx_port_queue, targ->nb_txports, targ->tx_rings, targ->nb_txrings);
71 static void display_tasks_draw_frame(struct screen_state *state)
73 const uint32_t n_tasks_tot = stats_get_n_tasks_tot();
75 display_page_init(&display_page_tasks);
77 struct display_table *core_task = display_page_add_table(&display_page_tasks);
78 struct display_table *rx_tx = display_page_add_table(&display_page_tasks);
80 display_table_init(core_task, "Core/Task");
82 nb_col = display_table_add_col(core_task);
83 display_column_init(nb_col, "Nb", 4);
84 name_col = display_table_add_col(core_task);
85 display_column_init(name_col, "Name", 7);
86 mode_col = display_table_add_col(core_task);
87 display_column_init(mode_col, "Mode", 9);
89 display_table_init(rx_tx, "Port ID/Ring Name");
90 rx_name_col = display_table_add_col(rx_tx);
91 display_column_init(rx_name_col, "RX", 9);
92 tx_name_col = display_table_add_col(rx_tx);
93 display_column_init(tx_name_col, "TX", 9);
95 struct display_table *stats = display_page_add_table(&display_page_tasks);
97 if (state->toggle == 0) {
98 display_table_init(stats, "Statistics per second");
100 idle_col = display_table_add_col(stats);
101 display_column_init(idle_col, "Idle (%)", 5);
103 rx_col = display_table_add_col(stats);
104 display_column_init(rx_col, "RX (K)", 9);
106 tx_col = display_table_add_col(stats);
107 display_column_init(tx_col, "TX (K)", 9);
109 tx_fail_col = display_table_add_col(stats);
110 display_column_init(tx_fail_col, "TX Fail (K)", 9);
112 discard_col = display_table_add_col(stats);
113 display_column_init(discard_col, "Discard (K)", 9);
115 handled_col = display_table_add_col(stats);
116 display_column_init(handled_col, "Handled (K)", 9);
118 if (stats_cpu_freq_enabled()) {
119 struct display_table *other = display_page_add_table(&display_page_tasks);
121 display_table_init(other, "Other");
123 cpp_col = display_table_add_col(other);
124 display_column_init(cpp_col, "CPP", 9);
126 ghz_col = display_table_add_col(other);
127 display_column_init(ghz_col, "Clk (GHz)", 9);
129 if (stats_mbm_enabled()) {
130 struct display_table *other = display_page_add_table(&display_page_tasks);
131 mbm_tot_col = display_table_add_col(other);
132 display_column_init(mbm_tot_col, "Tot Bdw(M)", 10);
133 mbm_loc_col = display_table_add_col(other);
134 display_column_init(mbm_loc_col, "Loc Bdw(M)", 10);
137 display_table_init(stats, "Total Statistics");
139 rx_col = display_table_add_col(stats);
140 display_column_init(rx_col, "RX (K)", 14);
142 tx_col = display_table_add_col(stats);
143 display_column_init(tx_col, "TX (K)", 14);
145 tx_fail_col = display_table_add_col(stats);
146 display_column_init(tx_fail_col, "TX Fail (K)", 14);
148 discard_col = display_table_add_col(stats);
149 display_column_init(discard_col, "Discard (K)", 14);
151 handled_col = display_table_add_col(stats);
152 display_column_init(handled_col, "Handled (K)", 14);
154 if (stats_cmt_enabled()) {
155 struct display_table *other = display_page_add_table(&display_page_tasks);
157 display_table_init(other, "Cache QoS Monitoring");
159 occup_col = display_table_add_col(other);
160 display_column_init(occup_col, "Occupancy (KB)", 15);
162 frac_col = display_table_add_col(other);
163 display_column_init(frac_col, "Fraction", 9);
165 if (stats_cat_enabled()) {
166 struct display_table *other = display_page_add_table(&display_page_tasks);
167 mask_col = display_table_add_col(other);
168 display_column_init(mask_col, "Cache mask", 10);
169 class_col = display_table_add_col(other);
170 display_column_init(class_col, "Class", 5);
173 display_page_draw_frame(&display_page_tasks, n_tasks_tot);
175 uint16_t element_count = 0;
177 struct lcore_cfg *lconf = NULL;
178 struct task_args *targ;
180 while (core_targ_next(&lconf, &targ, 0) == 0) {
181 PROX_ASSERT(element_count < RTE_MAX_LCORE * MAX_TASKS_PER_CORE);
183 stats_display_core_task_entry(lconf, targ, element_count);
185 task_stats_disp[element_count].lcore_id = lconf->id;
186 task_stats_disp[element_count].task_id = targ->id;
187 task_stats_disp[element_count].lcore_stat_id = stats_lcore_find_stat_id(lconf->id);
192 static void print_kpps(struct display_column *col, int row, uint64_t nb_pkts, uint64_t delta_t)
195 if (nb_pkts && nb_pkts /100 < delta_t) {
196 uint64_t int_part = nb_pkts/delta_t;
197 uint64_t frac_part = (nb_pkts - int_part * delta_t) * 1000 /delta_t;
198 display_column_print(col, row, "%2lu.%03lu", int_part, frac_part);
201 display_column_print(col, row, "%9lu", nb_pkts / delta_t);
205 static void display_core_task_stats_per_sec(const struct task_stats_disp *t, struct screen_state *state, int row)
207 struct task_stats_sample *last = stats_get_task_stats_sample(t->lcore_id, t->task_id, 1);
208 struct task_stats_sample *prev = stats_get_task_stats_sample(t->lcore_id, t->task_id, 0);
210 /* delta_t in units of clock ticks */
211 uint64_t delta_t = last->tsc - prev->tsc;
213 uint64_t empty_cycles = last->empty_cycles - prev->empty_cycles;
215 if (empty_cycles > delta_t) {
216 empty_cycles = 10000;
219 empty_cycles = empty_cycles * 10000 / delta_t;
222 /* empty_cycles has 2 digits after point, (usefull when only a very small idle time) */
224 display_column_print(idle_col, row, "%3lu.%02lu", empty_cycles / 100, empty_cycles % 100);
226 // Display per second statistics in Kpps unit
227 delta_t *= state->pps_unit;
229 print_kpps(rx_col, row, last->rx_pkt_count - prev->rx_pkt_count, delta_t);
230 print_kpps(tx_col, row, last->tx_pkt_count - prev->tx_pkt_count, delta_t);
231 print_kpps(tx_fail_col, row, last->drop_tx_fail - prev->drop_tx_fail, delta_t);
232 print_kpps(discard_col, row, last->drop_discard - prev->drop_discard, delta_t);
233 print_kpps(handled_col, row, last->drop_handled - prev->drop_handled, delta_t);
235 if (stats_cpu_freq_enabled()) {
236 uint8_t lcore_stat_id = t->lcore_stat_id;
237 struct lcore_stats_sample *clast = stats_get_lcore_stats_sample(lcore_stat_id, 1);
238 struct lcore_stats_sample *cprev = stats_get_lcore_stats_sample(lcore_stat_id, 0);
240 uint64_t adiff = clast->afreq - cprev->afreq;
241 uint64_t mdiff = clast->mfreq - cprev->mfreq;
245 uint64_t pkt_diff_rx = last->rx_pkt_count - prev->rx_pkt_count;
246 uint64_t pkt_diff_tx = last->tx_pkt_count - prev->tx_pkt_count;
248 uint64_t pkt_diff = pkt_diff_tx > pkt_diff_rx? pkt_diff_tx : pkt_diff_rx;
250 if (pkt_diff && mdiff) {
251 cpp = delta_t/pkt_diff*adiff/mdiff/1000;
256 mhz = tsc_hz*adiff/mdiff/1000000;
260 display_column_print(cpp_col, row, "%lu", cpp);
261 display_column_print(ghz_col, row, "%lu.%03lu", mhz/1000, mhz%1000);
263 if (stats_mbm_enabled()) {
264 struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
265 uint8_t lcore_stat_id = t->lcore_stat_id;
266 struct lcore_stats_sample *clast = stats_get_lcore_stats_sample(lcore_stat_id, 1);
267 struct lcore_stats_sample *cprev = stats_get_lcore_stats_sample(lcore_stat_id, 0);
268 if ((clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 20)
269 display_column_print(mbm_tot_col, row, "%lu", (clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 20);
271 display_column_print(mbm_tot_col, row, "0.%03lu", (clast->mbm_tot_bytes - cprev->mbm_tot_bytes) >> 10);
272 if( (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 20)
273 display_column_print(mbm_loc_col, row, "%lu", (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 20);
275 display_column_print(mbm_loc_col, row, "0.%03lu", (clast->mbm_loc_bytes - cprev->mbm_loc_bytes) >> 10);
279 static void display_core_task_stats_tot(const struct task_stats_disp *t, struct screen_state *state, int row)
281 struct task_stats *ts = stats_get_task_stats(t->lcore_id, t->task_id);
283 display_column_print(rx_col, row, "%lu", ts->tot_rx_pkt_count);
284 display_column_print(tx_col, row, "%lu", ts->tot_tx_pkt_count);
285 display_column_print(tx_fail_col, row, "%lu", ts->tot_drop_tx_fail);
286 display_column_print(discard_col, row, "%lu", ts->tot_drop_discard);
287 display_column_print(handled_col, row, "%lu", ts->tot_drop_handled);
289 if (stats_cmt_enabled()) {
290 struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
291 display_column_print(occup_col, row, "%lu", c->cmt_bytes >> 10);
292 display_column_print(frac_col, row, "%3lu.%02lu", c->cmt_fraction/100, c->cmt_fraction%100);
294 if (stats_cat_enabled()) {
295 struct lcore_stats *c = stats_get_lcore_stats(t->lcore_stat_id);
296 display_column_print(mask_col, row, "%x", c->cat_mask);
297 display_column_print(class_col, row, "%x", c->class);
301 static void display_tasks_draw_stats(struct screen_state *state)
303 const uint32_t n_tasks_tot = stats_get_n_tasks_tot();
305 for (uint8_t i = 0; i < n_tasks_tot; ++i) {
306 const struct task_stats_disp *disp = &task_stats_disp[i];
308 if (state->toggle == 0) {
309 display_core_task_stats_per_sec(disp, state, i);
311 display_core_task_stats_tot(disp, state, i);
316 static int display_tasks_get_height(void)
318 return stats_get_n_tasks_tot();
321 static struct display_screen display_screen_tasks = {
322 .draw_frame = display_tasks_draw_frame,
323 .draw_stats = display_tasks_draw_stats,
324 .get_height = display_tasks_get_height,
328 struct display_screen *display_tasks(void)
330 return &display_screen_tasks;