Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2017 Cavium, Inc
3 : : */
4 : :
5 : : #include "test_perf_common.h"
6 : :
7 : : /* See http://doc.dpdk.org/guides/tools/testeventdev.html for test details */
8 : :
9 : : static inline int
10 : 0 : atq_nb_event_queues(struct evt_options *opt)
11 : : {
12 : : /* nb_queues = number of producers */
13 : 0 : return opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR ?
14 : 0 : rte_eth_dev_count_avail() : evt_nr_active_lcores(opt->plcores);
15 : : }
16 : :
17 : : static __rte_always_inline void
18 : : atq_fwd_event(struct rte_event *const ev, uint8_t *const sched_type_list,
19 : : const uint8_t nb_stages)
20 : : {
21 : 0 : ev->sub_event_type++;
22 : 0 : ev->sched_type = sched_type_list[ev->sub_event_type % nb_stages];
23 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
24 : 0 : ev->event_type = RTE_EVENT_TYPE_CPU;
25 : 0 : }
26 : :
27 : : static __rte_always_inline void
28 : : atq_fwd_event_vector(struct rte_event *const ev, uint8_t *const sched_type_list,
29 : : const uint8_t nb_stages)
30 : : {
31 : 0 : ev->sub_event_type++;
32 : 0 : ev->sched_type = sched_type_list[ev->sub_event_type % nb_stages];
33 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
34 : 0 : ev->event_type = RTE_EVENT_TYPE_CPU_VECTOR;
35 : 0 : }
36 : :
37 : : static int
38 : 0 : perf_atq_worker(void *arg, const int enable_fwd_latency)
39 : : {
40 : : uint16_t enq = 0, deq = 0;
41 : : struct rte_event ev;
42 : 0 : PERF_WORKER_INIT;
43 : :
44 : 0 : while (t->done == false) {
45 : 0 : deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
46 : :
47 : 0 : if (!deq) {
48 : : rte_pause();
49 : 0 : continue;
50 : : }
51 : :
52 : 0 : if (prod_crypto_type && (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
53 : 0 : if (perf_handle_crypto_ev(&ev, &pe, enable_fwd_latency))
54 : 0 : continue;
55 : : }
56 : :
57 : 0 : stage = ev.sub_event_type % nb_stages;
58 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0)
59 : : /* first stage in pipeline, mark ts to compute fwd latency */
60 : 0 : perf_mark_fwd_latency(ev.event_ptr);
61 : :
62 : : /* last stage in pipeline */
63 : 0 : if (unlikely(stage == laststage)) {
64 : 0 : if (enable_fwd_latency)
65 : : cnt = perf_process_last_stage_latency(pool, prod_crypto_type,
66 : : &ev, w, bufs, sz, cnt);
67 : : else
68 : : cnt = perf_process_last_stage(pool, prod_crypto_type, &ev, w,
69 : : bufs, sz, cnt);
70 : : } else {
71 : : atq_fwd_event(&ev, sched_type_list, nb_stages);
72 : : do {
73 : 0 : enq = rte_event_enqueue_burst(dev, port, &ev,
74 : : 1);
75 : 0 : } while (!enq && !t->done);
76 : : }
77 : : }
78 : :
79 : 0 : perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
80 : :
81 : 0 : return 0;
82 : : }
83 : :
84 : : static int
85 : 0 : perf_atq_worker_burst(void *arg, const int enable_fwd_latency)
86 : : {
87 : : /* +1 to avoid prefetch out of array check */
88 : : struct rte_event ev[BURST_SIZE + 1];
89 : : uint16_t enq = 0, nb_rx = 0;
90 : 0 : PERF_WORKER_INIT;
91 : : uint16_t i;
92 : :
93 : 0 : while (t->done == false) {
94 : 0 : nb_rx = rte_event_dequeue_burst(dev, port, ev, BURST_SIZE, 0);
95 : :
96 : 0 : if (!nb_rx) {
97 : : rte_pause();
98 : 0 : continue;
99 : : }
100 : :
101 : 0 : for (i = 0; i < nb_rx; i++) {
102 : 0 : if (prod_crypto_type && (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
103 : 0 : if (perf_handle_crypto_ev(&ev[i], &pe, enable_fwd_latency))
104 : 0 : continue;
105 : : }
106 : :
107 : 0 : stage = ev[i].sub_event_type % nb_stages;
108 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0) {
109 : 0 : rte_prefetch0(ev[i+1].event_ptr);
110 : : /* first stage in pipeline.
111 : : * mark time stamp to compute fwd latency
112 : : */
113 : 0 : perf_mark_fwd_latency(ev[i].event_ptr);
114 : : }
115 : : /* last stage in pipeline */
116 : 0 : if (unlikely(stage == laststage)) {
117 : 0 : if (enable_fwd_latency)
118 : : cnt = perf_process_last_stage_latency(pool,
119 : : prod_crypto_type, &ev[i], w, bufs, sz, cnt);
120 : : else
121 : : cnt = perf_process_last_stage(pool, prod_crypto_type,
122 : : &ev[i], w, bufs, sz, cnt);
123 : :
124 : 0 : ev[i].op = RTE_EVENT_OP_RELEASE;
125 : : } else {
126 : : atq_fwd_event(&ev[i], sched_type_list,
127 : : nb_stages);
128 : : }
129 : : }
130 : :
131 : 0 : enq = rte_event_enqueue_burst(dev, port, ev, nb_rx);
132 : 0 : while ((enq < nb_rx) && !t->done) {
133 : 0 : enq += rte_event_enqueue_burst(dev, port,
134 : 0 : ev + enq, nb_rx - enq);
135 : : }
136 : : }
137 : :
138 : 0 : perf_worker_cleanup(pool, dev, port, ev, enq, nb_rx);
139 : :
140 : 0 : return 0;
141 : : }
142 : :
143 : : static int
144 : 0 : perf_atq_worker_vector(void *arg, const int enable_fwd_latency)
145 : : {
146 : : uint16_t enq = 0, deq = 0;
147 : : struct rte_event ev;
148 : 0 : PERF_WORKER_INIT;
149 : :
150 : : RTE_SET_USED(sz);
151 : : RTE_SET_USED(cnt);
152 : : RTE_SET_USED(prod_crypto_type);
153 : :
154 : 0 : while (t->done == false) {
155 : 0 : deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
156 : :
157 : 0 : if (!deq)
158 : 0 : continue;
159 : :
160 : 0 : if (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV_VECTOR) {
161 : 0 : if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
162 : 0 : continue;
163 : : }
164 : :
165 : 0 : stage = ev.sub_event_type % nb_stages;
166 : : /* First q in pipeline, mark timestamp to compute fwd latency */
167 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0)
168 : : perf_mark_fwd_latency(pe);
169 : :
170 : : /* Last stage in pipeline */
171 : 0 : if (unlikely(stage == laststage)) {
172 : 0 : perf_process_vector_last_stage(pool, t->ca_op_pool, &ev, w,
173 : : enable_fwd_latency);
174 : : } else {
175 : : atq_fwd_event_vector(&ev, sched_type_list, nb_stages);
176 : : do {
177 : 0 : enq = rte_event_enqueue_burst(dev, port, &ev, 1);
178 : 0 : } while (!enq && !t->done);
179 : : }
180 : : }
181 : :
182 : 0 : perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
183 : :
184 : 0 : return 0;
185 : : }
186 : :
187 : : static int
188 : 0 : worker_wrapper(void *arg)
189 : : {
190 : : struct worker_data *w = arg;
191 : 0 : struct evt_options *opt = w->t->opt;
192 : :
193 : 0 : const bool burst = evt_has_burst_mode(w->dev_id);
194 : 0 : const int fwd_latency = opt->fwd_latency;
195 : :
196 : : /* allow compiler to optimize */
197 : 0 : if (opt->ena_vector && opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
198 : 0 : return perf_atq_worker_vector(arg, fwd_latency);
199 : 0 : else if (!burst && !fwd_latency)
200 : 0 : return perf_atq_worker(arg, 0);
201 : 0 : else if (!burst && fwd_latency)
202 : 0 : return perf_atq_worker(arg, 1);
203 : 0 : else if (burst && !fwd_latency)
204 : 0 : return perf_atq_worker_burst(arg, 0);
205 : 0 : else if (burst && fwd_latency)
206 : 0 : return perf_atq_worker_burst(arg, 1);
207 : :
208 : 0 : rte_panic("invalid worker\n");
209 : : }
210 : :
211 : : static int
212 : 0 : perf_atq_launch_lcores(struct evt_test *test, struct evt_options *opt)
213 : : {
214 : 0 : return perf_launch_lcores(test, opt, worker_wrapper);
215 : : }
216 : :
217 : : static int
218 : 0 : perf_atq_eventdev_setup(struct evt_test *test, struct evt_options *opt)
219 : : {
220 : : int ret;
221 : : uint8_t queue;
222 : : uint8_t nb_queues;
223 : : uint8_t nb_ports;
224 : : uint16_t prod;
225 : : struct rte_event_dev_info dev_info;
226 : : struct test_perf *t = evt_test_priv(test);
227 : :
228 : 0 : nb_ports = evt_nr_active_lcores(opt->wlcores);
229 : 0 : nb_ports += (opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR ||
230 : 0 : opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) ? 0 :
231 : 0 : evt_nr_active_lcores(opt->plcores);
232 : :
233 : 0 : nb_queues = atq_nb_event_queues(opt);
234 : :
235 : 0 : ret = rte_event_dev_info_get(opt->dev_id, &dev_info);
236 : 0 : if (ret) {
237 : 0 : evt_err("failed to get eventdev info %d", opt->dev_id);
238 : 0 : return ret;
239 : : }
240 : :
241 : 0 : ret = evt_configure_eventdev(opt, nb_queues, nb_ports);
242 : 0 : if (ret) {
243 : 0 : evt_err("failed to configure eventdev %d", opt->dev_id);
244 : 0 : return ret;
245 : : }
246 : :
247 : 0 : struct rte_event_queue_conf q_conf = {
248 : : .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
249 : : .event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES,
250 : 0 : .nb_atomic_flows = opt->nb_flows,
251 : : .nb_atomic_order_sequences = opt->nb_flows,
252 : : };
253 : : /* queue configurations */
254 : 0 : for (queue = 0; queue < nb_queues; queue++) {
255 : 0 : ret = rte_event_queue_setup(opt->dev_id, queue, &q_conf);
256 : 0 : if (ret) {
257 : 0 : evt_err("failed to setup queue=%d", queue);
258 : 0 : return ret;
259 : : }
260 : : }
261 : :
262 : 0 : if (opt->wkr_deq_dep > dev_info.max_event_port_dequeue_depth)
263 : 0 : opt->wkr_deq_dep = dev_info.max_event_port_dequeue_depth;
264 : :
265 : : /* port configuration */
266 : 0 : const struct rte_event_port_conf p_conf = {
267 : 0 : .dequeue_depth = opt->wkr_deq_dep,
268 : : .enqueue_depth = dev_info.max_event_port_dequeue_depth,
269 : 0 : .new_event_threshold = dev_info.max_num_events,
270 : : };
271 : :
272 : 0 : ret = perf_event_dev_port_setup(test, opt, 1 /* stride */, nb_queues,
273 : : &p_conf);
274 : 0 : if (ret)
275 : : return ret;
276 : :
277 : 0 : if (!evt_has_distributed_sched(opt->dev_id)) {
278 : : uint32_t service_id;
279 : 0 : rte_event_dev_service_id_get(opt->dev_id, &service_id);
280 : 0 : ret = evt_service_setup(service_id);
281 : 0 : if (ret) {
282 : 0 : evt_err("No service lcore found to run event dev.");
283 : 0 : return ret;
284 : : }
285 : : }
286 : :
287 : 0 : ret = rte_event_dev_start(opt->dev_id);
288 : 0 : if (ret) {
289 : 0 : evt_err("failed to start eventdev %d", opt->dev_id);
290 : 0 : return ret;
291 : : }
292 : :
293 : 0 : if (opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR) {
294 : 0 : RTE_ETH_FOREACH_DEV(prod) {
295 : 0 : ret = rte_eth_dev_start(prod);
296 : 0 : if (ret) {
297 : 0 : evt_err("Ethernet dev [%d] failed to start. Using synthetic producer",
298 : : prod);
299 : 0 : return ret;
300 : : }
301 : :
302 : 0 : ret = rte_event_eth_rx_adapter_start(prod);
303 : 0 : if (ret) {
304 : 0 : evt_err("Rx adapter[%d] start failed", prod);
305 : 0 : return ret;
306 : : }
307 : : printf("%s: Port[%d] using Rx adapter[%d] started\n",
308 : : __func__, prod, prod);
309 : : }
310 : 0 : } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
311 : 0 : for (prod = 0; prod < opt->nb_timer_adptrs; prod++) {
312 : 0 : ret = rte_event_timer_adapter_start(
313 : 0 : t->timer_adptr[prod]);
314 : 0 : if (ret) {
315 : 0 : evt_err("failed to Start event timer adapter %d"
316 : : , prod);
317 : 0 : return ret;
318 : : }
319 : : }
320 : 0 : } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
321 : : uint8_t cdev_id, cdev_count;
322 : :
323 : 0 : cdev_count = rte_cryptodev_count();
324 : 0 : for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
325 : 0 : ret = rte_cryptodev_start(cdev_id);
326 : 0 : if (ret) {
327 : 0 : evt_err("Failed to start cryptodev %u",
328 : : cdev_id);
329 : 0 : return ret;
330 : : }
331 : : }
332 : : }
333 : :
334 : : return 0;
335 : : }
336 : :
337 : : static void
338 : 0 : perf_atq_opt_dump(struct evt_options *opt)
339 : : {
340 : 0 : perf_opt_dump(opt, atq_nb_event_queues(opt));
341 : 0 : }
342 : :
343 : : static int
344 : 0 : perf_atq_opt_check(struct evt_options *opt)
345 : : {
346 : 0 : return perf_opt_check(opt, atq_nb_event_queues(opt));
347 : : }
348 : :
349 : : static bool
350 : 0 : perf_atq_capability_check(struct evt_options *opt)
351 : : {
352 : : struct rte_event_dev_info dev_info;
353 : :
354 : 0 : rte_event_dev_info_get(opt->dev_id, &dev_info);
355 : 0 : if (dev_info.max_event_queues < atq_nb_event_queues(opt) ||
356 : 0 : dev_info.max_event_ports < perf_nb_event_ports(opt)) {
357 : 0 : evt_err("not enough eventdev queues=%d/%d or ports=%d/%d",
358 : : atq_nb_event_queues(opt), dev_info.max_event_queues,
359 : : perf_nb_event_ports(opt), dev_info.max_event_ports);
360 : : }
361 : 0 : if (!evt_has_all_types_queue(opt->dev_id))
362 : 0 : return false;
363 : :
364 : : return true;
365 : : }
366 : :
367 : : static const struct evt_test_ops perf_atq = {
368 : : .cap_check = perf_atq_capability_check,
369 : : .opt_check = perf_atq_opt_check,
370 : : .opt_dump = perf_atq_opt_dump,
371 : : .test_setup = perf_test_setup,
372 : : .ethdev_setup = perf_ethdev_setup,
373 : : .cryptodev_setup = perf_cryptodev_setup,
374 : : .ethdev_rx_stop = perf_ethdev_rx_stop,
375 : : .mempool_setup = perf_mempool_setup,
376 : : .eventdev_setup = perf_atq_eventdev_setup,
377 : : .launch_lcores = perf_atq_launch_lcores,
378 : : .eventdev_destroy = perf_eventdev_destroy,
379 : : .mempool_destroy = perf_mempool_destroy,
380 : : .ethdev_destroy = perf_ethdev_destroy,
381 : : .cryptodev_destroy = perf_cryptodev_destroy,
382 : : .test_result = perf_test_result,
383 : : .test_destroy = perf_test_destroy,
384 : : };
385 : :
386 : 0 : EVT_TEST_REGISTER(perf_atq);
|