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 : perf_queue_nb_event_queues(struct evt_options *opt)
11 : : {
12 : : /* nb_queues = number of producers * number of stages */
13 : 0 : uint8_t nb_prod = opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR ?
14 : 0 : rte_eth_dev_count_avail() : evt_nr_active_lcores(opt->plcores);
15 : 0 : return nb_prod * opt->nb_stages;
16 : : }
17 : :
18 : : static __rte_always_inline void
19 : : fwd_event(struct rte_event *const ev, uint8_t *const sched_type_list,
20 : : const uint8_t nb_stages)
21 : : {
22 : 0 : ev->queue_id++;
23 : 0 : ev->sched_type = sched_type_list[ev->queue_id % nb_stages];
24 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
25 : 0 : ev->event_type = RTE_EVENT_TYPE_CPU;
26 : 0 : }
27 : :
28 : : static __rte_always_inline void
29 : : fwd_event_vector(struct rte_event *const ev, uint8_t *const sched_type_list,
30 : : const uint8_t nb_stages)
31 : : {
32 : 0 : ev->queue_id++;
33 : 0 : ev->sched_type = sched_type_list[ev->queue_id % nb_stages];
34 : 0 : ev->op = RTE_EVENT_OP_FORWARD;
35 : 0 : ev->event_type = RTE_EVENT_TYPE_CPU_VECTOR;
36 : 0 : }
37 : :
38 : : static int
39 : 0 : perf_queue_worker(void *arg, const int enable_fwd_latency)
40 : : {
41 : : uint16_t enq = 0, deq = 0;
42 : : struct rte_event ev;
43 : 0 : PERF_WORKER_INIT;
44 : :
45 : : RTE_SET_USED(pe);
46 : 0 : while (t->done == false) {
47 : 0 : deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
48 : :
49 : 0 : if (!deq) {
50 : : rte_pause();
51 : 0 : continue;
52 : : }
53 : :
54 : 0 : if ((prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) &&
55 : 0 : (ev.event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
56 : 0 : if (perf_handle_crypto_ev(&ev))
57 : 0 : continue;
58 : : } else {
59 : : pe = ev.event_ptr;
60 : : }
61 : :
62 : 0 : stage = ev.queue_id % nb_stages;
63 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0)
64 : : /* first q in pipeline, mark timestamp to compute fwd latency */
65 : : perf_mark_fwd_latency(prod_type, &ev);
66 : :
67 : : /* last stage in pipeline */
68 : 0 : if (unlikely(stage == laststage)) {
69 : 0 : if (enable_fwd_latency)
70 : : cnt = perf_process_last_stage_latency(pool, prod_type,
71 : : &ev, w, bufs, sz, cnt);
72 : : else
73 : : cnt = perf_process_last_stage(pool, prod_type,
74 : : &ev, w, bufs, sz, cnt);
75 : : } else {
76 : : fwd_event(&ev, sched_type_list, nb_stages);
77 : : do {
78 : : enq = rte_event_enqueue_burst(dev, port, &ev, 1);
79 : 0 : } while (!enq && !t->done);
80 : : }
81 : : }
82 : :
83 : 0 : perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
84 : :
85 : 0 : return 0;
86 : : }
87 : :
88 : : static int
89 : 0 : perf_queue_worker_burst(void *arg, const int enable_fwd_latency)
90 : : {
91 : : /* +1 to avoid prefetch out of array check */
92 : : struct rte_event ev[BURST_SIZE + 1];
93 : : uint16_t enq = 0, nb_rx = 0;
94 : 0 : PERF_WORKER_INIT;
95 : : uint16_t i;
96 : :
97 : : RTE_SET_USED(pe);
98 : 0 : while (t->done == false) {
99 : 0 : nb_rx = rte_event_dequeue_burst(dev, port, ev, BURST_SIZE, 0);
100 : :
101 : 0 : if (!nb_rx) {
102 : : rte_pause();
103 : 0 : continue;
104 : : }
105 : :
106 : 0 : for (i = 0; i < nb_rx; i++) {
107 : 0 : if ((prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) &&
108 : 0 : (ev[i].event_type == RTE_EVENT_TYPE_CRYPTODEV)) {
109 : 0 : if (perf_handle_crypto_ev(&ev[i]))
110 : 0 : continue;
111 : : }
112 : :
113 : 0 : stage = ev[i].queue_id % nb_stages;
114 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0) {
115 : 0 : rte_prefetch0(ev[i+1].event_ptr);
116 : : /* first queue in pipeline.
117 : : * mark time stamp to compute fwd latency
118 : : */
119 : : perf_mark_fwd_latency(prod_type, &ev[i]);
120 : : }
121 : : /* last stage in pipeline */
122 : 0 : if (unlikely(stage == laststage)) {
123 : 0 : if (enable_fwd_latency)
124 : : cnt = perf_process_last_stage_latency(pool,
125 : : prod_type, &ev[i], w, bufs, sz, cnt);
126 : : else
127 : : cnt = perf_process_last_stage(pool, prod_type,
128 : : &ev[i], w, bufs, sz, cnt);
129 : :
130 : 0 : ev[i].op = RTE_EVENT_OP_RELEASE;
131 : : } else {
132 : : fwd_event(&ev[i], sched_type_list, nb_stages);
133 : : }
134 : : }
135 : :
136 : :
137 : 0 : enq = rte_event_enqueue_burst(dev, port, ev, nb_rx);
138 : 0 : while (enq < nb_rx && !t->done) {
139 : 0 : enq += rte_event_enqueue_burst(dev, port,
140 : 0 : ev + enq, nb_rx - enq);
141 : : }
142 : : }
143 : :
144 : 0 : perf_worker_cleanup(pool, dev, port, ev, enq, nb_rx);
145 : :
146 : 0 : return 0;
147 : : }
148 : :
149 : : static int
150 : 0 : perf_queue_worker_crypto_vector(void *arg, const int enable_fwd_latency)
151 : : {
152 : : uint16_t enq = 0, deq = 0;
153 : : struct rte_event ev;
154 : 0 : PERF_WORKER_INIT;
155 : :
156 : : RTE_SET_USED(sz);
157 : : RTE_SET_USED(cnt);
158 : : RTE_SET_USED(prod_type);
159 : :
160 : 0 : while (t->done == false) {
161 : 0 : deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
162 : :
163 : 0 : if (!deq)
164 : 0 : continue;
165 : :
166 : 0 : if (perf_handle_crypto_vector_ev(&ev, &pe, enable_fwd_latency))
167 : 0 : continue;
168 : :
169 : 0 : stage = ev.queue_id % nb_stages;
170 : : /* First q in pipeline, mark timestamp to compute fwd latency */
171 : 0 : if (enable_fwd_latency && !prod_timer_type && stage == 0)
172 : 0 : pe->timestamp = rte_get_timer_cycles();
173 : :
174 : : /* Last stage in pipeline */
175 : 0 : if (unlikely(stage == laststage)) {
176 : 0 : perf_process_crypto_vector_last_stage(pool, t->ca_op_pool, &ev, w,
177 : : enable_fwd_latency);
178 : : } else {
179 : : fwd_event_vector(&ev, sched_type_list, nb_stages);
180 : : do {
181 : : enq = rte_event_enqueue_burst(dev, port, &ev, 1);
182 : 0 : } while (!enq && !t->done);
183 : : }
184 : : }
185 : :
186 : 0 : perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
187 : :
188 : 0 : return 0;
189 : : }
190 : :
191 : : static int
192 : 0 : perf_queue_worker_vector(void *arg, const int enable_fwd_latency)
193 : : {
194 : : uint16_t enq = 0, deq = 0;
195 : : struct rte_event ev;
196 : 0 : PERF_WORKER_INIT;
197 : :
198 : : RTE_SET_USED(pe);
199 : : RTE_SET_USED(sz);
200 : : RTE_SET_USED(cnt);
201 : : RTE_SET_USED(prod_type);
202 : : RTE_SET_USED(prod_timer_type);
203 : :
204 : 0 : while (t->done == false) {
205 : 0 : deq = rte_event_dequeue_burst(dev, port, &ev, 1, 0);
206 : 0 : if (!deq)
207 : 0 : continue;
208 : :
209 : 0 : if (ev.event_type != RTE_EVENT_TYPE_CPU_VECTOR) {
210 : 0 : w->processed_pkts++;
211 : 0 : continue;
212 : : }
213 : :
214 : 0 : stage = ev.sub_event_type % nb_stages;
215 : 0 : if (enable_fwd_latency && stage == 0)
216 : : /* first stage in pipeline, mark ts to compute fwd latency */
217 : 0 : ev.vec->u64s[0] = rte_get_timer_cycles();
218 : :
219 : : /* Last stage in pipeline */
220 : 0 : if (unlikely(stage == laststage)) {
221 : 0 : w->processed_vecs++;
222 : 0 : if (enable_fwd_latency)
223 : 0 : w->latency += rte_get_timer_cycles() - ev.vec->u64s[0];
224 : 0 : rte_mempool_put(pool, ev.event_ptr);
225 : : } else {
226 : : fwd_event_vector(&ev, sched_type_list, nb_stages);
227 : : do {
228 : : enq = rte_event_enqueue_burst(dev, port, &ev, 1);
229 : 0 : } while (!enq && !t->done);
230 : : }
231 : : }
232 : 0 : perf_worker_cleanup(pool, dev, port, &ev, enq, deq);
233 : :
234 : 0 : return 0;
235 : : }
236 : :
237 : : static int
238 : 0 : worker_wrapper(void *arg)
239 : : {
240 : : struct worker_data *w = arg;
241 : 0 : struct evt_options *opt = w->t->opt;
242 : :
243 : 0 : const bool burst = evt_has_burst_mode(w->dev_id);
244 : 0 : const int fwd_latency = opt->fwd_latency;
245 : :
246 : : /* allow compiler to optimize */
247 : 0 : if (opt->ena_vector && opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR)
248 : 0 : return perf_queue_worker_crypto_vector(arg, fwd_latency);
249 : 0 : else if (opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR)
250 : 0 : return perf_queue_worker_vector(arg, fwd_latency);
251 : 0 : else if (!burst && !fwd_latency)
252 : 0 : return perf_queue_worker(arg, 0);
253 : 0 : else if (!burst && fwd_latency)
254 : 0 : return perf_queue_worker(arg, 1);
255 : 0 : else if (burst && !fwd_latency)
256 : 0 : return perf_queue_worker_burst(arg, 0);
257 : 0 : else if (burst && fwd_latency)
258 : 0 : return perf_queue_worker_burst(arg, 1);
259 : :
260 : 0 : rte_panic("invalid worker\n");
261 : : }
262 : :
263 : : static int
264 : 0 : perf_queue_launch_lcores(struct evt_test *test, struct evt_options *opt)
265 : : {
266 : 0 : return perf_launch_lcores(test, opt, worker_wrapper);
267 : : }
268 : :
269 : : static int
270 : 0 : perf_queue_eventdev_setup(struct evt_test *test, struct evt_options *opt)
271 : : {
272 : : uint8_t queue;
273 : 0 : int nb_stages = opt->nb_stages;
274 : : int ret;
275 : : int nb_ports;
276 : : int nb_queues;
277 : : uint16_t prod;
278 : : struct rte_event_dev_info dev_info;
279 : : struct test_perf *t = evt_test_priv(test);
280 : :
281 : 0 : nb_ports = evt_nr_active_lcores(opt->wlcores);
282 : 0 : nb_ports += opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR ||
283 : 0 : opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR ||
284 : : opt->prod_type == EVT_PROD_TYPE_EVENT_VECTOR_ADPTR ?
285 : 0 : 0 :
286 : 0 : evt_nr_active_lcores(opt->plcores);
287 : :
288 : 0 : nb_queues = perf_queue_nb_event_queues(opt);
289 : :
290 : 0 : ret = rte_event_dev_info_get(opt->dev_id, &dev_info);
291 : 0 : if (ret) {
292 : 0 : evt_err("failed to get eventdev info %d", opt->dev_id);
293 : 0 : return ret;
294 : : }
295 : :
296 : 0 : ret = evt_configure_eventdev(opt, nb_queues, nb_ports);
297 : 0 : if (ret) {
298 : 0 : evt_err("failed to configure eventdev %d", opt->dev_id);
299 : 0 : return ret;
300 : : }
301 : :
302 : 0 : struct rte_event_queue_conf q_conf = {
303 : : .priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
304 : 0 : .nb_atomic_flows = opt->nb_flows,
305 : : .nb_atomic_order_sequences = opt->nb_flows,
306 : : };
307 : : /* queue configurations */
308 : 0 : for (queue = 0; queue < nb_queues; queue++) {
309 : 0 : q_conf.schedule_type =
310 : 0 : (opt->sched_type_list[queue % nb_stages]);
311 : :
312 : 0 : if (opt->q_priority) {
313 : 0 : uint8_t stage_pos = queue % nb_stages;
314 : : /* Configure event queues(stage 0 to stage n) with
315 : : * RTE_EVENT_DEV_PRIORITY_LOWEST to
316 : : * RTE_EVENT_DEV_PRIORITY_HIGHEST.
317 : : */
318 : 0 : uint8_t step = RTE_EVENT_DEV_PRIORITY_LOWEST /
319 : 0 : (nb_stages - 1);
320 : : /* Higher prio for the queues closer to last stage */
321 : 0 : q_conf.priority = RTE_EVENT_DEV_PRIORITY_LOWEST -
322 : 0 : (step * stage_pos);
323 : : }
324 : 0 : ret = rte_event_queue_setup(opt->dev_id, queue, &q_conf);
325 : 0 : if (ret) {
326 : 0 : evt_err("failed to setup queue=%d", queue);
327 : 0 : return ret;
328 : : }
329 : : }
330 : :
331 : 0 : if (opt->wkr_deq_dep > dev_info.max_event_port_dequeue_depth)
332 : 0 : opt->wkr_deq_dep = dev_info.max_event_port_dequeue_depth;
333 : :
334 : : /* port configuration */
335 : 0 : const struct rte_event_port_conf p_conf = {
336 : 0 : .dequeue_depth = opt->wkr_deq_dep,
337 : : .enqueue_depth = dev_info.max_event_port_dequeue_depth,
338 : 0 : .new_event_threshold = dev_info.max_num_events,
339 : : };
340 : :
341 : 0 : ret = perf_event_dev_port_setup(test, opt, nb_stages /* stride */,
342 : : nb_queues, &p_conf);
343 : 0 : if (ret)
344 : : return ret;
345 : :
346 : 0 : if (!evt_has_distributed_sched(opt->dev_id)) {
347 : : uint32_t service_id;
348 : 0 : rte_event_dev_service_id_get(opt->dev_id, &service_id);
349 : 0 : ret = evt_service_setup(service_id);
350 : 0 : if (ret) {
351 : 0 : evt_err("No service lcore found to run event dev.");
352 : 0 : return ret;
353 : : }
354 : : }
355 : :
356 : 0 : ret = rte_event_dev_start(opt->dev_id);
357 : 0 : if (ret) {
358 : 0 : evt_err("failed to start eventdev %d", opt->dev_id);
359 : 0 : return ret;
360 : : }
361 : :
362 : 0 : if (opt->prod_type == EVT_PROD_TYPE_ETH_RX_ADPTR) {
363 : 0 : RTE_ETH_FOREACH_DEV(prod) {
364 : 0 : ret = rte_eth_dev_start(prod);
365 : 0 : if (ret) {
366 : 0 : evt_err("Ethernet dev [%d] failed to start. Using synthetic producer",
367 : : prod);
368 : 0 : return ret;
369 : : }
370 : :
371 : 0 : ret = rte_event_eth_rx_adapter_start(prod);
372 : 0 : if (ret) {
373 : 0 : evt_err("Rx adapter[%d] start failed", prod);
374 : 0 : return ret;
375 : : }
376 : : printf("%s: Port[%d] using Rx adapter[%d] started\n",
377 : : __func__, prod, prod);
378 : : }
379 : 0 : } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_TIMER_ADPTR) {
380 : 0 : for (prod = 0; prod < opt->nb_timer_adptrs; prod++) {
381 : 0 : ret = rte_event_timer_adapter_start(
382 : 0 : t->timer_adptr[prod]);
383 : 0 : if (ret) {
384 : 0 : evt_err("failed to Start event timer adapter %d"
385 : : , prod);
386 : 0 : return ret;
387 : : }
388 : : }
389 : 0 : } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_CRYPTO_ADPTR) {
390 : : uint8_t cdev_id, cdev_count;
391 : :
392 : 0 : cdev_count = rte_cryptodev_count();
393 : 0 : for (cdev_id = 0; cdev_id < cdev_count; cdev_id++) {
394 : 0 : ret = rte_cryptodev_start(cdev_id);
395 : 0 : if (ret) {
396 : 0 : evt_err("Failed to start cryptodev %u",
397 : : cdev_id);
398 : 0 : return ret;
399 : : }
400 : : }
401 : 0 : } else if (opt->prod_type == EVT_PROD_TYPE_EVENT_DMA_ADPTR) {
402 : : uint8_t dma_dev_id = 0, dma_dev_count;
403 : :
404 : 0 : dma_dev_count = rte_dma_count_avail();
405 : 0 : if (dma_dev_count == 0) {
406 : 0 : evt_err("No dma devices available\n");
407 : 0 : return -ENODEV;
408 : : }
409 : :
410 : 0 : ret = rte_dma_start(dma_dev_id);
411 : 0 : if (ret) {
412 : 0 : evt_err("Failed to start dmadev %u", dma_dev_id);
413 : 0 : return ret;
414 : : }
415 : : }
416 : :
417 : : return 0;
418 : : }
419 : :
420 : : static void
421 : 0 : perf_queue_opt_dump(struct evt_options *opt)
422 : : {
423 : 0 : evt_dump_fwd_latency(opt);
424 : 0 : perf_opt_dump(opt, perf_queue_nb_event_queues(opt));
425 : 0 : }
426 : :
427 : : static int
428 : 0 : perf_queue_opt_check(struct evt_options *opt)
429 : : {
430 : 0 : return perf_opt_check(opt, perf_queue_nb_event_queues(opt));
431 : : }
432 : :
433 : : static bool
434 : 0 : perf_queue_capability_check(struct evt_options *opt)
435 : : {
436 : : struct rte_event_dev_info dev_info;
437 : :
438 : 0 : rte_event_dev_info_get(opt->dev_id, &dev_info);
439 : 0 : if (dev_info.max_event_queues < perf_queue_nb_event_queues(opt) ||
440 : 0 : dev_info.max_event_ports < perf_nb_event_ports(opt)) {
441 : 0 : evt_err("not enough eventdev queues=%d/%d or ports=%d/%d",
442 : : perf_queue_nb_event_queues(opt),
443 : : dev_info.max_event_queues,
444 : : perf_nb_event_ports(opt), dev_info.max_event_ports);
445 : : }
446 : :
447 : 0 : return true;
448 : : }
449 : :
450 : : static const struct evt_test_ops perf_queue = {
451 : : .cap_check = perf_queue_capability_check,
452 : : .opt_check = perf_queue_opt_check,
453 : : .opt_dump = perf_queue_opt_dump,
454 : : .test_setup = perf_test_setup,
455 : : .mempool_setup = perf_mempool_setup,
456 : : .ethdev_setup = perf_ethdev_setup,
457 : : .cryptodev_setup = perf_cryptodev_setup,
458 : : .dmadev_setup = perf_dmadev_setup,
459 : : .ethdev_rx_stop = perf_ethdev_rx_stop,
460 : : .eventdev_setup = perf_queue_eventdev_setup,
461 : : .launch_lcores = perf_queue_launch_lcores,
462 : : .eventdev_destroy = perf_eventdev_destroy,
463 : : .mempool_destroy = perf_mempool_destroy,
464 : : .ethdev_destroy = perf_ethdev_destroy,
465 : : .cryptodev_destroy = perf_cryptodev_destroy,
466 : : .dmadev_destroy = perf_dmadev_destroy,
467 : : .test_result = perf_test_result,
468 : : .test_destroy = perf_test_destroy,
469 : : };
470 : :
471 : 0 : EVT_TEST_REGISTER(perf_queue);
|
