Multiple changes for June release
[samplevnf.git] / VNFs / DPPD-PROX / display_latency.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 "display.h"
18 #include "display_latency.h"
19 #include "stats_latency.h"
20 #include "lconf.h"
21
22 static struct display_column *min_col;
23 static struct display_column *max_col;
24 static struct display_column *avg_col;
25 static struct display_column *stddev_col;
26 static struct display_column *accuracy_limit_col;
27 static struct display_column *used_col;
28 static struct display_column *lost_col;
29 static struct display_page display_page_latency;
30
31 static void display_latency_draw_frame(struct screen_state *screen_state)
32 {
33         const uint32_t n_latency = stats_get_n_latency();
34         struct display_column *core_col;
35         struct display_column *port_col;
36
37         display_page_init(&display_page_latency);
38
39         struct display_table *core = display_page_add_table(&display_page_latency);
40         struct display_table *port = display_page_add_table(&display_page_latency);
41         struct display_table *lat = display_page_add_table(&display_page_latency);
42         struct display_table *acc = display_page_add_table(&display_page_latency);
43         struct display_table *other = display_page_add_table(&display_page_latency);
44
45         display_table_init(core, "Core");
46         core_col = display_table_add_col(core);
47         display_column_init(core_col, "Nb", 4);
48
49         display_table_init(port, "Port Nb");
50         port_col = display_table_add_col(port);
51         display_column_init(port_col, "RX", 8);
52
53         if (screen_state->toggle == 0)
54                 display_table_init(lat, "Measured Latency per interval");
55         else
56                 display_table_init(lat, "Measured Latency since reset");
57
58         min_col = display_table_add_col(lat);
59         display_column_init(min_col, "Min (us)", 20);
60         max_col = display_table_add_col(lat);
61         display_column_init(max_col, "Max (us)", 20);
62         avg_col = display_table_add_col(lat);
63         display_column_init(avg_col, "Avg (us)", 20);
64         stddev_col = display_table_add_col(lat);
65         display_column_init(stddev_col, "Stddev (us)", 20);
66
67         display_table_init(acc, "Accuracy ");
68         used_col = display_table_add_col(acc);
69         display_column_init(used_col, "Used Packets (%)", 16);
70         accuracy_limit_col = display_table_add_col(acc);
71         display_column_init(accuracy_limit_col, "limit (us)", 16);
72
73         display_table_init(other, "Other");
74
75         lost_col = display_table_add_col(other);
76         display_column_init(lost_col, "Lost Packets", 16);
77
78         display_page_draw_frame(&display_page_latency, n_latency);
79
80         for (uint16_t i = 0; i < n_latency; ++i) {
81                 uint32_t lcore_id = stats_latency_get_core_id(i);
82                 uint32_t task_id = stats_latency_get_task_id(i);
83                 struct task_args *targ = &lcore_cfg[lcore_id].targs[task_id];
84
85                 display_column_print(core_col, i, "%2u/%1u", lcore_id, task_id);
86                 display_column_port_ring(port_col, i, targ->rx_port_queue, targ->nb_rxports, targ->rx_rings, targ->nb_rxrings);
87         }
88 }
89
90 #define AFTER_POINT 1000000
91
92 static void display_stats_latency_entry(int row, struct stats_latency *stats_latency)
93 {
94         struct time_unit_err avg = stats_latency->avg;
95         struct time_unit_err min = stats_latency->min;
96         struct time_unit_err max = stats_latency->max;
97         struct time_unit_err stddev = stats_latency->stddev;
98         struct time_unit accuracy_limit = stats_latency->accuracy_limit;
99
100         uint32_t used = 0;
101
102         if (stats_latency->tot_all_packets)
103                 used = stats_latency->tot_packets * (100 * AFTER_POINT) / stats_latency->tot_all_packets;
104
105         char dst[32];
106
107         if (stats_latency->tot_packets) {
108                 display_column_print(min_col, row, "%s", print_time_unit_err_usec(dst, &min));
109                 display_column_print(max_col, row, "%s", print_time_unit_err_usec(dst, &max));
110                 display_column_print(avg_col, row, "%s", print_time_unit_err_usec(dst, &avg));
111                 display_column_print(stddev_col, row, "%s", print_time_unit_err_usec(dst, &stddev));
112         } else {
113                 display_column_print(min_col, row, "%s", "N/A");
114                 display_column_print(max_col, row, "%s", "N/A");
115                 display_column_print(avg_col, row, "%s", "N/A");
116                 display_column_print(stddev_col, row, "%s", "N/A");
117         }
118
119         display_column_print(accuracy_limit_col, row, "%s", print_time_unit_usec(dst, &accuracy_limit));
120         display_column_print(lost_col, row, "%16"PRIu64"", stats_latency->lost_packets);
121         display_column_print(used_col, row, "%3u.%06u", used / AFTER_POINT, used % AFTER_POINT);
122 }
123
124 static void display_latency_draw_stats(struct screen_state *screen_state)
125 {
126         const uint32_t n_latency = stats_get_n_latency();
127         struct stats_latency *stats_latency;
128
129         for (uint16_t i = 0; i < n_latency; ++i) {
130                 if (screen_state->toggle == 0)
131                         stats_latency = stats_latency_get(i);
132                 else
133                         stats_latency = stats_latency_tot_get(i);
134
135                 display_stats_latency_entry(i, stats_latency);
136         }
137 }
138
139 static int display_latency_get_height(void)
140 {
141         return stats_get_n_latency();
142 }
143
144 static struct display_screen display_screen_latency = {
145         .draw_frame = display_latency_draw_frame,
146         .draw_stats = display_latency_draw_stats,
147         .get_height = display_latency_get_height,
148         .title = "latency",
149 };
150
151 struct display_screen *display_latency(void)
152 {
153         return &display_screen_latency;
154 }