net: add MPLS header structure
[dpdk.git] / app / test-eventdev / evt_options.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2017 Cavium, Inc
3  */
4
5 #ifndef _EVT_OPTIONS_
6 #define _EVT_OPTIONS_
7
8 #include <stdio.h>
9 #include <stdbool.h>
10
11 #include <rte_common.h>
12 #include <rte_ethdev.h>
13 #include <rte_eventdev.h>
14 #include <rte_lcore.h>
15
16 #include "evt_common.h"
17
18 #define EVT_BOOL_FMT(x)          ((x) ? "true" : "false")
19
20 #define EVT_VERBOSE              ("verbose")
21 #define EVT_DEVICE               ("dev")
22 #define EVT_TEST                 ("test")
23 #define EVT_PROD_LCORES          ("plcores")
24 #define EVT_WORK_LCORES          ("wlcores")
25 #define EVT_NB_FLOWS             ("nb_flows")
26 #define EVT_SOCKET_ID            ("socket_id")
27 #define EVT_POOL_SZ              ("pool_sz")
28 #define EVT_WKR_DEQ_DEP          ("worker_deq_depth")
29 #define EVT_NB_PKTS              ("nb_pkts")
30 #define EVT_NB_STAGES            ("nb_stages")
31 #define EVT_SCHED_TYPE_LIST      ("stlist")
32 #define EVT_FWD_LATENCY          ("fwd_latency")
33 #define EVT_QUEUE_PRIORITY       ("queue_priority")
34 #define EVT_PROD_ETHDEV          ("prod_type_ethdev")
35 #define EVT_PROD_TIMERDEV        ("prod_type_timerdev")
36 #define EVT_PROD_TIMERDEV_BURST  ("prod_type_timerdev_burst")
37 #define EVT_NB_TIMERS            ("nb_timers")
38 #define EVT_NB_TIMER_ADPTRS      ("nb_timer_adptrs")
39 #define EVT_TIMER_TICK_NSEC      ("timer_tick_nsec")
40 #define EVT_MAX_TMO_NSEC         ("max_tmo_nsec")
41 #define EVT_EXPIRY_NSEC          ("expiry_nsec")
42 #define EVT_HELP                 ("help")
43
44 enum evt_prod_type {
45         EVT_PROD_TYPE_NONE,
46         EVT_PROD_TYPE_SYNT,          /* Producer type Synthetic i.e. CPU. */
47         EVT_PROD_TYPE_ETH_RX_ADPTR,  /* Producer type Eth Rx Adapter. */
48         EVT_PROD_TYPE_EVENT_TIMER_ADPTR,  /* Producer type Timer Adapter. */
49         EVT_PROD_TYPE_MAX,
50 };
51
52 struct evt_options {
53 #define EVT_TEST_NAME_MAX_LEN     32
54         char test_name[EVT_TEST_NAME_MAX_LEN];
55         bool plcores[RTE_MAX_LCORE];
56         bool wlcores[RTE_MAX_LCORE];
57         uint8_t sched_type_list[EVT_MAX_STAGES];
58         uint32_t nb_flows;
59         int socket_id;
60         int pool_sz;
61         int nb_stages;
62         int verbose_level;
63         uint64_t nb_pkts;
64         uint8_t nb_timer_adptrs;
65         uint64_t nb_timers;
66         uint64_t timer_tick_nsec;
67         uint64_t optm_timer_tick_nsec;
68         uint64_t max_tmo_nsec;
69         uint64_t expiry_nsec;
70         uint16_t wkr_deq_dep;
71         uint8_t dev_id;
72         uint32_t fwd_latency:1;
73         uint32_t q_priority:1;
74         enum evt_prod_type prod_type;
75         uint8_t timdev_use_burst;
76         uint8_t timdev_cnt;
77 };
78
79 void evt_options_default(struct evt_options *opt);
80 int evt_options_parse(struct evt_options *opt, int argc, char **argv);
81 void evt_options_dump(struct evt_options *opt);
82
83 /* options check helpers */
84 static inline bool
85 evt_lcores_has_overlap(bool lcores[], int lcore)
86 {
87         if (lcores[lcore] == true) {
88                 evt_err("lcore overlaps at %d", lcore);
89                 return true;
90         }
91
92         return false;
93 }
94
95 static inline bool
96 evt_lcores_has_overlap_multi(bool lcoresx[], bool lcoresy[])
97 {
98         int i;
99
100         for (i = 0; i < RTE_MAX_LCORE; i++) {
101                 if (lcoresx[i] && lcoresy[i]) {
102                         evt_err("lcores overlaps at %d", i);
103                         return true;
104                 }
105         }
106         return false;
107 }
108
109 static inline bool
110 evt_has_active_lcore(bool lcores[])
111 {
112         int i;
113
114         for (i = 0; i < RTE_MAX_LCORE; i++)
115                 if (lcores[i])
116                         return true;
117         return false;
118 }
119
120 static inline int
121 evt_nr_active_lcores(bool lcores[])
122 {
123         int i;
124         int c = 0;
125
126         for (i = 0; i < RTE_MAX_LCORE; i++)
127                 if (lcores[i])
128                         c++;
129         return c;
130 }
131
132 static inline int
133 evt_get_first_active_lcore(bool lcores[])
134 {
135         int i;
136
137         for (i = 0; i < RTE_MAX_LCORE; i++)
138                 if (lcores[i])
139                         return i;
140         return -1;
141 }
142
143 static inline bool
144 evt_has_disabled_lcore(bool lcores[])
145 {
146         int i;
147
148         for (i = 0; i < RTE_MAX_LCORE; i++)
149                 if ((lcores[i] == true) && !(rte_lcore_is_enabled(i)))
150                         return true;
151         return false;
152 }
153
154 static inline bool
155 evt_has_invalid_stage(struct evt_options *opt)
156 {
157         if (!opt->nb_stages) {
158                 evt_err("need minimum one stage, check --stlist");
159                 return true;
160         }
161         if (opt->nb_stages > EVT_MAX_STAGES) {
162                 evt_err("requested changes are beyond EVT_MAX_STAGES=%d",
163                         EVT_MAX_STAGES);
164                 return true;
165         }
166         return false;
167 }
168
169 static inline bool
170 evt_has_invalid_sched_type(struct evt_options *opt)
171 {
172         int i;
173
174         for (i = 0; i < opt->nb_stages; i++) {
175                 if (opt->sched_type_list[i] > RTE_SCHED_TYPE_PARALLEL) {
176                         evt_err("invalid sched_type %d at %d",
177                                 opt->sched_type_list[i], i);
178                         return true;
179                 }
180         }
181         return false;
182 }
183
184 /* option dump helpers */
185 static inline void
186 evt_dump_worker_lcores(struct evt_options *opt)
187 {
188         int c;
189
190         evt_dump_begin("worker lcores");
191         for  (c = 0; c < RTE_MAX_LCORE; c++) {
192                 if (opt->wlcores[c])
193                         printf("%d ", c);
194         }
195         evt_dump_end;
196 }
197
198 static inline void
199 evt_dump_producer_lcores(struct evt_options *opt)
200 {
201         int c;
202
203         evt_dump_begin("producer lcores");
204         for  (c = 0; c < RTE_MAX_LCORE; c++) {
205                 if (opt->plcores[c])
206                         printf("%d ", c);
207         }
208         evt_dump_end;
209 }
210
211 static inline void
212 evt_dump_nb_flows(struct evt_options *opt)
213 {
214         evt_dump("nb_flows", "%d", opt->nb_flows);
215 }
216
217 static inline void
218 evt_dump_worker_dequeue_depth(struct evt_options *opt)
219 {
220         evt_dump("worker deq depth", "%d", opt->wkr_deq_dep);
221 }
222
223 static inline void
224 evt_dump_nb_stages(struct evt_options *opt)
225 {
226         evt_dump("nb_stages", "%d", opt->nb_stages);
227 }
228
229 static inline void
230 evt_dump_fwd_latency(struct evt_options *opt)
231 {
232         evt_dump("fwd_latency", "%s", EVT_BOOL_FMT(opt->fwd_latency));
233 }
234
235 static inline void
236 evt_dump_queue_priority(struct evt_options *opt)
237 {
238         evt_dump("queue_priority", "%s", EVT_BOOL_FMT(opt->q_priority));
239 }
240
241 static inline const char*
242 evt_sched_type_2_str(uint8_t sched_type)
243 {
244
245         if (sched_type == RTE_SCHED_TYPE_ORDERED)
246                 return "O";
247         else if (sched_type == RTE_SCHED_TYPE_ATOMIC)
248                 return "A";
249         else if (sched_type == RTE_SCHED_TYPE_PARALLEL)
250                 return "P";
251         else
252                 return "I";
253 }
254
255 static inline void
256 evt_dump_sched_type_list(struct evt_options *opt)
257 {
258         int i;
259
260         evt_dump_begin("sched_type_list");
261         for (i = 0; i < opt->nb_stages; i++)
262                 printf("%s ", evt_sched_type_2_str(opt->sched_type_list[i]));
263
264         evt_dump_end;
265 }
266
267 #define EVT_PROD_MAX_NAME_LEN 50
268 static inline void
269 evt_dump_producer_type(struct evt_options *opt)
270 {
271         char name[EVT_PROD_MAX_NAME_LEN];
272
273         switch (opt->prod_type) {
274         default:
275         case EVT_PROD_TYPE_SYNT:
276                 snprintf(name, EVT_PROD_MAX_NAME_LEN,
277                                 "Synthetic producer lcores");
278                 break;
279         case EVT_PROD_TYPE_ETH_RX_ADPTR:
280                 snprintf(name, EVT_PROD_MAX_NAME_LEN,
281                                 "Ethdev Rx Adapter producers");
282                 evt_dump("nb_ethdev", "%d", rte_eth_dev_count_avail());
283                 break;
284         case EVT_PROD_TYPE_EVENT_TIMER_ADPTR:
285                 if (opt->timdev_use_burst)
286                         snprintf(name, EVT_PROD_MAX_NAME_LEN,
287                                 "Event timer adapter burst mode producer");
288                 else
289                         snprintf(name, EVT_PROD_MAX_NAME_LEN,
290                                 "Event timer adapter producer");
291                 evt_dump("nb_timer_adapters", "%d", opt->nb_timer_adptrs);
292                 evt_dump("max_tmo_nsec", "%"PRIu64"", opt->max_tmo_nsec);
293                 evt_dump("expiry_nsec", "%"PRIu64"", opt->expiry_nsec);
294                 if (opt->optm_timer_tick_nsec)
295                         evt_dump("optm_timer_tick_nsec", "%"PRIu64"",
296                                         opt->optm_timer_tick_nsec);
297                 else
298                         evt_dump("timer_tick_nsec", "%"PRIu64"",
299                                         opt->timer_tick_nsec);
300                 break;
301         }
302         evt_dump("prod_type", "%s", name);
303 }
304
305 #endif /* _EVT_OPTIONS_ */