Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2016-2020 Intel Corporation
3 : : */
4 : :
5 : : #include <stdio.h>
6 : : #include <string.h>
7 : : #include <stdint.h>
8 : : #include <errno.h>
9 : : #include <unistd.h>
10 : : #include <sys/queue.h>
11 : :
12 : : #include <rte_memory.h>
13 : : #include <rte_memzone.h>
14 : : #include <rte_launch.h>
15 : : #include <rte_eal.h>
16 : : #include <rte_per_lcore.h>
17 : : #include <rte_lcore.h>
18 : : #include <rte_debug.h>
19 : : #include <rte_ethdev.h>
20 : : #include <rte_cycles.h>
21 : : #include <rte_eventdev.h>
22 : : #include <rte_pause.h>
23 : :
24 : : #include "dlb2_priv.h"
25 : : #include "rte_pmd_dlb2.h"
26 : :
27 : : #define MAX_PORTS 32
28 : : #define MAX_QIDS 32
29 : : #define DEFAULT_NUM_SEQ_NUMS 64
30 : :
31 : : static struct rte_mempool *eventdev_func_mempool;
32 : : static int evdev;
33 : :
34 : : struct test {
35 : : struct rte_mempool *mbuf_pool;
36 : : int nb_qids;
37 : : };
38 : :
39 : : /* initialization and config */
40 : : static inline int
41 : 0 : init(struct test *t, int nb_queues, int nb_ports)
42 : : {
43 : 0 : struct rte_event_dev_config config = {0};
44 : : struct rte_event_dev_info info;
45 : : int ret;
46 : :
47 : : memset(t, 0, sizeof(*t));
48 : :
49 : 0 : t->mbuf_pool = eventdev_func_mempool;
50 : :
51 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
52 : : printf("%d: Error querying device info\n", __LINE__);
53 : 0 : return -1;
54 : : }
55 : :
56 : 0 : config.nb_event_queues = nb_queues;
57 : 0 : config.nb_event_ports = nb_ports;
58 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
59 : 0 : config.nb_events_limit = info.max_num_events;
60 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
61 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
62 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
63 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
64 : :
65 : 0 : ret = rte_event_dev_configure(evdev, &config);
66 [ # # ]: 0 : if (ret < 0)
67 : : printf("%d: Error configuring device\n", __LINE__);
68 : :
69 : : return ret;
70 : : }
71 : :
72 : : static inline int
73 : 0 : create_ports(int num_ports)
74 : : {
75 : : int i;
76 : :
77 [ # # ]: 0 : if (num_ports > MAX_PORTS)
78 : : return -1;
79 : :
80 [ # # ]: 0 : for (i = 0; i < num_ports; i++) {
81 : : struct rte_event_port_conf conf;
82 : :
83 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, i, &conf)) {
84 : : printf("%d: Error querying default port conf\n",
85 : : __LINE__);
86 : 0 : return -1;
87 : : }
88 : :
89 [ # # ]: 0 : if (rte_event_port_setup(evdev, i, &conf) < 0) {
90 : : printf("%d: Error setting up port %d\n", __LINE__, i);
91 : 0 : return -1;
92 : : }
93 : : }
94 : :
95 : : return 0;
96 : : }
97 : :
98 : : static inline int
99 : 0 : create_lb_qids(struct test *t, int num_qids, uint32_t flags)
100 : : {
101 : : int i;
102 : :
103 [ # # ]: 0 : for (i = t->nb_qids; i < t->nb_qids + num_qids; i++) {
104 : : struct rte_event_queue_conf conf;
105 : :
106 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, i, &conf)) {
107 : : printf("%d: Error querying default queue conf\n",
108 : : __LINE__);
109 : 0 : return -1;
110 : : }
111 : :
112 : 0 : conf.schedule_type = flags;
113 : :
114 [ # # ]: 0 : if (conf.schedule_type == RTE_SCHED_TYPE_PARALLEL)
115 : 0 : conf.nb_atomic_order_sequences = 0;
116 : : else
117 : 0 : conf.nb_atomic_order_sequences = DEFAULT_NUM_SEQ_NUMS;
118 : :
119 [ # # ]: 0 : if (rte_event_queue_setup(evdev, i, &conf) < 0) {
120 : : printf("%d: error creating qid %d\n", __LINE__, i);
121 : 0 : return -1;
122 : : }
123 : : }
124 : :
125 : 0 : t->nb_qids += num_qids;
126 [ # # ]: 0 : if (t->nb_qids > MAX_QIDS)
127 : 0 : return -1;
128 : :
129 : : return 0;
130 : : }
131 : :
132 : : static inline int
133 : : create_atomic_qids(struct test *t, int num_qids)
134 : : {
135 : 0 : return create_lb_qids(t, num_qids, RTE_SCHED_TYPE_ATOMIC);
136 : : }
137 : :
138 : : /* destruction */
139 : : static inline void
140 : 0 : cleanup(void)
141 : : {
142 : : int ret = 0;
143 : :
144 : 0 : rte_event_dev_stop(evdev);
145 : 0 : ret = rte_event_dev_close(evdev);
146 : :
147 [ # # ]: 0 : if (ret)
148 : : printf("%d: rte_event_dev_close failed, ret = %d\n",
149 : : __LINE__, ret);
150 : 0 : };
151 : :
152 : : static inline int
153 : 0 : enqueue_timeout(uint8_t port_id, struct rte_event *ev, uint64_t tmo_us)
154 : : {
155 : : const uint64_t start = rte_get_timer_cycles();
156 : 0 : const uint64_t ticks = (tmo_us * rte_get_timer_hz()) / 1E6;
157 : :
158 [ # # ]: 0 : while ((rte_get_timer_cycles() - start) < ticks) {
159 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, port_id, ev, 1) == 1)
160 : : return 0;
161 : :
162 [ # # ]: 0 : if (rte_errno != -ENOSPC) {
163 : : printf("enqueue_burst returned rte_errno %d\n",
164 : : rte_errno);
165 : 0 : return -1;
166 : : }
167 : : }
168 : : printf("%s time out\n", __func__);
169 : 0 : return -1;
170 : : }
171 : :
172 : : static void
173 : 0 : flush(uint8_t id __rte_unused, struct rte_event event, void *arg __rte_unused)
174 : : {
175 : 0 : rte_pktmbuf_free(event.mbuf);
176 : 0 : }
177 : :
178 : : static int
179 : 0 : test_stop_flush(struct test *t) /* test to check we can properly flush events */
180 : : {
181 : : struct rte_event ev;
182 : : uint32_t dequeue_depth;
183 : : unsigned int i, count;
184 : : uint8_t queue_id;
185 : :
186 : 0 : ev.op = RTE_EVENT_OP_NEW;
187 : :
188 [ # # # # ]: 0 : if (init(t, 2, 1) < 0 ||
189 [ # # ]: 0 : create_ports(1) < 0 ||
190 : : create_atomic_qids(t, 2) < 0) {
191 : : printf("%d: Error initializing device\n", __LINE__);
192 : 0 : return -1;
193 : : }
194 : :
195 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, NULL, NULL, 0) != 2) {
196 : : printf("%d: Error linking queues to the port\n", __LINE__);
197 : 0 : goto err;
198 : : }
199 : :
200 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
201 : : printf("%d: Error with start call\n", __LINE__);
202 : 0 : goto err;
203 : : }
204 : :
205 : : /* Unlink queue 1 so the PMD's stop callback has to cleanup an unlinked
206 : : * queue.
207 : : */
208 : 0 : queue_id = 1;
209 : :
210 [ # # ]: 0 : if (rte_event_port_unlink(evdev, 0, &queue_id, 1) != 1) {
211 : : printf("%d: Error unlinking queue 1 from port\n", __LINE__);
212 : 0 : goto err;
213 : : }
214 : :
215 [ # # ]: 0 : if (t->mbuf_pool)
216 : 0 : count = rte_mempool_avail_count(t->mbuf_pool);
217 : : else {
218 : : printf("%d: mbuf_pool is NULL\n", __LINE__);
219 : 0 : goto err;
220 : : }
221 : :
222 [ # # ]: 0 : if (rte_event_port_attr_get(evdev,
223 : : 0,
224 : : RTE_EVENT_PORT_ATTR_DEQ_DEPTH,
225 : : &dequeue_depth)) {
226 : : printf("%d: Error retrieving dequeue depth\n", __LINE__);
227 : 0 : goto err;
228 : : }
229 : :
230 : : /* Send QEs to queue 0 */
231 [ # # ]: 0 : for (i = 0; i < dequeue_depth + 1; i++) {
232 : 0 : ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
233 : 0 : ev.queue_id = 0;
234 : 0 : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
235 : :
236 [ # # ]: 0 : if (enqueue_timeout(0, &ev, 1000)) {
237 : : printf("%d: Error enqueuing events\n", __LINE__);
238 : 0 : goto err;
239 : : }
240 : : }
241 : :
242 : : /* Send QEs to queue 1 */
243 [ # # ]: 0 : for (i = 0; i < dequeue_depth + 1; i++) {
244 : 0 : ev.mbuf = rte_pktmbuf_alloc(t->mbuf_pool);
245 : 0 : ev.queue_id = 1;
246 : 0 : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
247 : :
248 [ # # ]: 0 : if (enqueue_timeout(0, &ev, 1000)) {
249 : : printf("%d: Error enqueuing events\n", __LINE__);
250 : 0 : goto err;
251 : : }
252 : : }
253 : :
254 : : /* Now the DLB is scheduling events from the port to the IQ, and at
255 : : * least one event should be remaining in each queue.
256 : : */
257 : :
258 [ # # ]: 0 : if (rte_event_dev_stop_flush_callback_register(evdev, flush, NULL)) {
259 : : printf("%d: Error installing the flush callback\n", __LINE__);
260 : 0 : goto err;
261 : : }
262 : :
263 : 0 : cleanup();
264 : :
265 [ # # ]: 0 : if (count != rte_mempool_avail_count(t->mbuf_pool)) {
266 : : printf("%d: Error executing the flush callback\n", __LINE__);
267 : 0 : goto err;
268 : : }
269 : :
270 [ # # ]: 0 : if (rte_event_dev_stop_flush_callback_register(evdev, NULL, NULL)) {
271 : : printf("%d: Error uninstalling the flush callback\n", __LINE__);
272 : 0 : goto err;
273 : : }
274 : :
275 : : return 0;
276 : 0 : err:
277 : 0 : cleanup();
278 : 0 : return -1;
279 : : }
280 : :
281 : : static int
282 : 0 : test_single_link(void)
283 : : {
284 : 0 : struct rte_event_dev_config config = {0};
285 : : struct rte_event_queue_conf queue_conf;
286 : : struct rte_event_port_conf port_conf;
287 : : struct rte_event_dev_info info;
288 : : uint8_t queue_id;
289 : : int ret;
290 : :
291 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
292 : : printf("%d: Error querying device info\n", __LINE__);
293 : 0 : return -1;
294 : : }
295 : :
296 : 0 : config.nb_event_queues = 2;
297 : 0 : config.nb_event_ports = 2;
298 : 0 : config.nb_single_link_event_port_queues = 1;
299 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
300 : 0 : config.nb_events_limit = info.max_num_events;
301 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
302 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
303 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
304 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
305 : :
306 : 0 : ret = rte_event_dev_configure(evdev, &config);
307 [ # # ]: 0 : if (ret < 0) {
308 : : printf("%d: Error configuring device\n", __LINE__);
309 : 0 : return -1;
310 : : }
311 : :
312 : : /* Create a directed port */
313 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
314 : : printf("%d: Error querying default port conf\n", __LINE__);
315 : 0 : goto err;
316 : : }
317 : :
318 : 0 : port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
319 : :
320 [ # # ]: 0 : if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
321 : : printf("%d: port 0 setup expected to succeed\n", __LINE__);
322 : 0 : goto err;
323 : : }
324 : :
325 : : /* Attempt to create another directed port */
326 [ # # ]: 0 : if (rte_event_port_setup(evdev, 1, &port_conf) == 0) {
327 : : printf("%d: port 1 setup expected to fail\n", __LINE__);
328 : 0 : goto err;
329 : : }
330 : :
331 : 0 : port_conf.event_port_cfg = 0;
332 : :
333 : : /* Create a load-balanced port */
334 [ # # ]: 0 : if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
335 : : printf("%d: port 1 setup expected to succeed\n", __LINE__);
336 : 0 : goto err;
337 : : }
338 : :
339 : : /* Create a directed queue */
340 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
341 : : printf("%d: Error querying default queue conf\n", __LINE__);
342 : 0 : goto err;
343 : : }
344 : :
345 : 0 : queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
346 : :
347 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
348 : : printf("%d: queue 0 setup expected to succeed\n", __LINE__);
349 : 0 : goto err;
350 : : }
351 : :
352 : : /* Attempt to create another directed queue */
353 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 1, &queue_conf) == 0) {
354 : : printf("%d: queue 1 setup expected to fail\n", __LINE__);
355 : 0 : goto err;
356 : : }
357 : :
358 : : /* Create a load-balanced queue */
359 : 0 : queue_conf.event_queue_cfg = 0;
360 : :
361 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
362 : : printf("%d: queue 1 setup expected to succeed\n", __LINE__);
363 : 0 : goto err;
364 : : }
365 : :
366 : : /* Attempt to link directed and load-balanced resources */
367 : 0 : queue_id = 1;
368 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) == 1) {
369 : : printf("%d: port 0 link expected to fail\n", __LINE__);
370 : 0 : goto err;
371 : : }
372 : :
373 : 0 : queue_id = 0;
374 [ # # ]: 0 : if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) == 1) {
375 : : printf("%d: port 1 link expected to fail\n", __LINE__);
376 : 0 : goto err;
377 : : }
378 : :
379 : : /* Link ports to queues */
380 : 0 : queue_id = 0;
381 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
382 : : printf("%d: port 0 link expected to succeed\n", __LINE__);
383 : 0 : goto err;
384 : : }
385 : :
386 : 0 : queue_id = 1;
387 [ # # ]: 0 : if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
388 : : printf("%d: port 1 link expected to succeed\n", __LINE__);
389 : 0 : goto err;
390 : : }
391 : :
392 : 0 : ret = rte_event_dev_close(evdev);
393 [ # # ]: 0 : if (ret)
394 : : printf("%d: rte_event_dev_close failed, ret = %d\n",
395 : : __LINE__, ret);
396 : :
397 : : return 0;
398 : :
399 : 0 : err:
400 : 0 : ret = rte_event_dev_close(evdev);
401 [ # # ]: 0 : if (ret)
402 : : printf("%d: rte_event_dev_close failed, ret = %d\n",
403 : : __LINE__, ret);
404 : :
405 : : return -1;
406 : : }
407 : :
408 : : #define NUM_LDB_PORTS 64
409 : : #define NUM_LDB_QUEUES 32
410 : :
411 : : static int
412 : 0 : test_info_get(void)
413 : : {
414 : 0 : struct rte_event_dev_config config = {0};
415 : : struct rte_event_dev_info info;
416 : : int ret;
417 : :
418 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
419 : : printf("%d: Error querying device info\n", __LINE__);
420 : 0 : return -1;
421 : : }
422 : :
423 [ # # ]: 0 : if (info.max_event_ports != NUM_LDB_PORTS) {
424 : 0 : printf("%d: Got %u ports, expected %u\n",
425 : : __LINE__, info.max_event_ports, NUM_LDB_PORTS);
426 : 0 : goto err;
427 : : }
428 : :
429 [ # # ]: 0 : if (info.max_event_queues != NUM_LDB_QUEUES) {
430 : 0 : printf("%d: Got %u queues, expected %u\n",
431 : : __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
432 : 0 : goto err;
433 : : }
434 : :
435 : 0 : config.nb_event_ports = info.max_event_ports;
436 : 0 : config.nb_event_queues = NUM_LDB_QUEUES + info.max_event_ports / 2;
437 : 0 : config.nb_single_link_event_port_queues = info.max_event_ports / 2;
438 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
439 : 0 : config.nb_events_limit = info.max_num_events;
440 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
441 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
442 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
443 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
444 : :
445 : 0 : ret = rte_event_dev_configure(evdev, &config);
446 [ # # ]: 0 : if (ret < 0) {
447 : : printf("%d: Error configuring device\n", __LINE__);
448 : 0 : return -1;
449 : : }
450 : :
451 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
452 : : printf("%d: Error querying device info\n", __LINE__);
453 : 0 : goto err;
454 : : }
455 : :
456 : : /* The DLB2 PMD only reports load-balanced ports and queues in its
457 : : * info_get function. Confirm that these values don't include the
458 : : * directed port or queue counts.
459 : : */
460 : :
461 [ # # ]: 0 : if (info.max_event_ports != NUM_LDB_PORTS) {
462 : 0 : printf("%d: Got %u ports, expected %u\n",
463 : : __LINE__, info.max_event_ports, NUM_LDB_PORTS);
464 : 0 : goto err;
465 : : }
466 : :
467 [ # # ]: 0 : if (info.max_event_queues != NUM_LDB_QUEUES) {
468 : 0 : printf("%d: Got %u queues, expected %u\n",
469 : : __LINE__, info.max_event_queues, NUM_LDB_QUEUES);
470 : 0 : goto err;
471 : : }
472 : :
473 : 0 : ret = rte_event_dev_close(evdev);
474 [ # # ]: 0 : if (ret) {
475 : : printf("%d: rte_event_dev_close failed, ret = %d\n",
476 : : __LINE__, ret);
477 : 0 : return -1;
478 : : }
479 : : return 0;
480 : :
481 : 0 : err:
482 : 0 : ret = rte_event_dev_close(evdev);
483 [ # # ]: 0 : if (ret)
484 : : printf("%d: rte_event_dev_close failed, ret = %d\n",
485 : : __LINE__, ret);
486 : :
487 : : return -1;
488 : : }
489 : :
490 : : static int
491 : 0 : test_reconfiguration_link(void)
492 : : {
493 : 0 : struct rte_event_dev_config config = {0};
494 : : struct rte_event_queue_conf queue_conf;
495 : : struct rte_event_port_conf port_conf;
496 : : struct rte_event_dev_info info;
497 : : uint8_t queue_id;
498 : : int ret, i;
499 : :
500 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
501 : : printf("%d: Error querying device info\n", __LINE__);
502 : 0 : return -1;
503 : : }
504 : :
505 : 0 : config.nb_event_queues = 2;
506 : 0 : config.nb_event_ports = 2;
507 : 0 : config.nb_single_link_event_port_queues = 0;
508 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
509 : 0 : config.nb_events_limit = info.max_num_events;
510 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
511 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
512 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
513 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
514 : :
515 : : /* Configure the device with 2 LDB ports and 2 LDB queues */
516 : 0 : ret = rte_event_dev_configure(evdev, &config);
517 [ # # ]: 0 : if (ret < 0) {
518 : : printf("%d: Error configuring device\n", __LINE__);
519 : 0 : return -1;
520 : : }
521 : :
522 : : /* Configure the ports and queues */
523 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
524 : : printf("%d: Error querying default port conf\n", __LINE__);
525 : 0 : goto err;
526 : : }
527 : :
528 [ # # ]: 0 : for (i = 0; i < 2; i++) {
529 [ # # ]: 0 : if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
530 : : printf("%d: port %d setup expected to succeed\n",
531 : : __LINE__, i);
532 : 0 : goto err;
533 : : }
534 : : }
535 : :
536 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
537 : : printf("%d: Error querying default queue conf\n", __LINE__);
538 : 0 : goto err;
539 : : }
540 : :
541 [ # # ]: 0 : for (i = 0; i < 2; i++) {
542 [ # # ]: 0 : if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
543 : : printf("%d: queue %d setup expected to succeed\n",
544 : : __LINE__, i);
545 : 0 : goto err;
546 : : }
547 : : }
548 : :
549 : : /* Link P0->Q0 and P1->Q1 */
550 [ # # ]: 0 : for (i = 0; i < 2; i++) {
551 : 0 : queue_id = i;
552 : :
553 [ # # ]: 0 : if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
554 : : printf("%d: port %d link expected to succeed\n",
555 : : __LINE__, i);
556 : 0 : goto err;
557 : : }
558 : : }
559 : :
560 : : /* Start the device */
561 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
562 : : printf("%d: device start failed\n", __LINE__);
563 : 0 : goto err;
564 : : }
565 : :
566 : : /* Stop the device */
567 : 0 : rte_event_dev_stop(evdev);
568 : :
569 : : /* Reconfigure device */
570 : 0 : ret = rte_event_dev_configure(evdev, &config);
571 [ # # ]: 0 : if (ret < 0) {
572 : : printf("%d: Error re-configuring device\n", __LINE__);
573 : 0 : return -1;
574 : : }
575 : :
576 : : /* Configure P1 and Q1, leave P0 and Q0 to be configured by the PMD. */
577 [ # # ]: 0 : if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
578 : : printf("%d: port 1 setup expected to succeed\n",
579 : : __LINE__);
580 : 0 : goto err;
581 : : }
582 : :
583 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 1, &queue_conf) < 0) {
584 : : printf("%d: queue 1 setup expected to succeed\n",
585 : : __LINE__);
586 : 0 : goto err;
587 : : }
588 : :
589 : : /* Link P0->Q0 and Q1 */
590 [ # # ]: 0 : for (i = 0; i < 2; i++) {
591 : 0 : queue_id = i;
592 : :
593 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
594 : : printf("%d: P0->Q%d link expected to succeed\n",
595 : : __LINE__, i);
596 : 0 : goto err;
597 : : }
598 : : }
599 : :
600 : : /* Link P1->Q0 and Q1 */
601 [ # # ]: 0 : for (i = 0; i < 2; i++) {
602 : 0 : queue_id = i;
603 : :
604 [ # # ]: 0 : if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
605 : : printf("%d: P1->Q%d link expected to succeed\n",
606 : : __LINE__, i);
607 : 0 : goto err;
608 : : }
609 : : }
610 : :
611 : : /* Start the device */
612 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
613 : : printf("%d: device start failed\n", __LINE__);
614 : 0 : goto err;
615 : : }
616 : :
617 : : /* Stop the device */
618 : 0 : rte_event_dev_stop(evdev);
619 : :
620 : : /* Configure device with 2 DIR ports and 2 DIR queues */
621 : 0 : config.nb_single_link_event_port_queues = 2;
622 : :
623 : 0 : ret = rte_event_dev_configure(evdev, &config);
624 [ # # ]: 0 : if (ret < 0) {
625 : : printf("%d: Error configuring device\n", __LINE__);
626 : 0 : return -1;
627 : : }
628 : :
629 : : /* Configure the ports and queues */
630 : 0 : port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
631 : :
632 [ # # ]: 0 : for (i = 0; i < 2; i++) {
633 [ # # ]: 0 : if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
634 : : printf("%d: port %d setup expected to succeed\n",
635 : : __LINE__, i);
636 : 0 : goto err;
637 : : }
638 : : }
639 : :
640 : 0 : queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
641 : :
642 [ # # ]: 0 : for (i = 0; i < 2; i++) {
643 [ # # ]: 0 : if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
644 : : printf("%d: queue %d setup expected to succeed\n",
645 : : __LINE__, i);
646 : 0 : goto err;
647 : : }
648 : : }
649 : :
650 : : /* Link P0->Q0 and P1->Q1 */
651 [ # # ]: 0 : for (i = 0; i < 2; i++) {
652 : 0 : queue_id = i;
653 : :
654 [ # # ]: 0 : if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
655 : : printf("%d: port %d link expected to succeed\n",
656 : : __LINE__, i);
657 : 0 : goto err;
658 : : }
659 : : }
660 : :
661 : : /* Start the device */
662 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
663 : : printf("%d: device start failed\n", __LINE__);
664 : 0 : goto err;
665 : : }
666 : :
667 : : /* Stop the device */
668 : 0 : rte_event_dev_stop(evdev);
669 : :
670 : : /* Reconfigure device */
671 : 0 : ret = rte_event_dev_configure(evdev, &config);
672 [ # # ]: 0 : if (ret < 0) {
673 : : printf("%d: Error re-configuring device\n", __LINE__);
674 : 0 : return -1;
675 : : }
676 : :
677 : : /* Configure P1 and Q0, leave P0 and Q1 to be configured by the PMD. */
678 [ # # ]: 0 : if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
679 : : printf("%d: port 1 setup expected to succeed\n",
680 : : __LINE__);
681 : 0 : goto err;
682 : : }
683 : :
684 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
685 : : printf("%d: queue 1 setup expected to succeed\n",
686 : : __LINE__);
687 : 0 : goto err;
688 : : }
689 : :
690 : : /* Link P0->Q1 */
691 : 0 : queue_id = 1;
692 : :
693 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
694 : : printf("%d: P0->Q%d link expected to succeed\n",
695 : : __LINE__, i);
696 : 0 : goto err;
697 : : }
698 : :
699 : : /* Link P1->Q0 */
700 : 0 : queue_id = 0;
701 : :
702 [ # # ]: 0 : if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
703 : : printf("%d: P1->Q%d link expected to succeed\n",
704 : : __LINE__, i);
705 : 0 : goto err;
706 : : }
707 : :
708 : : /* Start the device */
709 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
710 : : printf("%d: device start failed\n", __LINE__);
711 : 0 : goto err;
712 : : }
713 : :
714 : 0 : rte_event_dev_stop(evdev);
715 : :
716 : 0 : config.nb_event_queues = 5;
717 : 0 : config.nb_event_ports = 5;
718 : 0 : config.nb_single_link_event_port_queues = 1;
719 : :
720 : 0 : ret = rte_event_dev_configure(evdev, &config);
721 [ # # ]: 0 : if (ret < 0) {
722 : : printf("%d: Error re-configuring device\n", __LINE__);
723 : 0 : return -1;
724 : : }
725 : :
726 [ # # ]: 0 : for (i = 0; i < config.nb_event_queues - 1; i++) {
727 : 0 : port_conf.event_port_cfg = 0;
728 : 0 : queue_conf.event_queue_cfg = 0;
729 : :
730 [ # # ]: 0 : if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
731 : : printf("%d: port %d setup expected to succeed\n",
732 : : __LINE__, i);
733 : 0 : goto err;
734 : : }
735 : :
736 [ # # ]: 0 : if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
737 : : printf("%d: queue %d setup expected to succeed\n",
738 : : __LINE__, i);
739 : 0 : goto err;
740 : : }
741 : :
742 : 0 : queue_id = i;
743 : :
744 [ # # ]: 0 : if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
745 : : printf("%d: P%d->Q%d link expected to succeed\n",
746 : : __LINE__, i, i);
747 : 0 : goto err;
748 : : }
749 : : }
750 : :
751 : 0 : port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_SINGLE_LINK;
752 : 0 : queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
753 : :
754 [ # # ]: 0 : if (rte_event_port_setup(evdev, i, &port_conf) < 0) {
755 : : printf("%d: port %d setup expected to succeed\n",
756 : : __LINE__, i);
757 : 0 : goto err;
758 : : }
759 : :
760 [ # # ]: 0 : if (rte_event_queue_setup(evdev, i, &queue_conf) < 0) {
761 : : printf("%d: queue %d setup expected to succeed\n",
762 : : __LINE__, i);
763 : 0 : goto err;
764 : : }
765 : :
766 : 0 : queue_id = i;
767 : :
768 [ # # ]: 0 : if (rte_event_port_link(evdev, i, &queue_id, NULL, 1) != 1) {
769 : : printf("%d: P%d->Q%d link expected to succeed\n",
770 : : __LINE__, i, i);
771 : 0 : goto err;
772 : : }
773 : :
774 : : /* Start the device */
775 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
776 : : printf("%d: device start failed\n", __LINE__);
777 : 0 : goto err;
778 : : }
779 : :
780 : : /* Stop the device */
781 : 0 : rte_event_dev_stop(evdev);
782 : :
783 : 0 : config.nb_event_ports += 1;
784 : :
785 : : /* Reconfigure device with 1 more load-balanced port */
786 : 0 : ret = rte_event_dev_configure(evdev, &config);
787 [ # # ]: 0 : if (ret < 0) {
788 : : printf("%d: Error re-configuring device\n", __LINE__);
789 : 0 : return -1;
790 : : }
791 : :
792 : 0 : port_conf.event_port_cfg = 0;
793 : :
794 : : /* Configure the new port */
795 [ # # ]: 0 : if (rte_event_port_setup(evdev, config.nb_event_ports - 1,
796 : : &port_conf) < 0) {
797 : : printf("%d: port 1 setup expected to succeed\n",
798 : : __LINE__);
799 : 0 : goto err;
800 : : }
801 : :
802 : : /* Start the device */
803 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
804 : : printf("%d: device start failed\n", __LINE__);
805 : 0 : goto err;
806 : : }
807 : :
808 : 0 : cleanup();
809 : 0 : return 0;
810 : :
811 : 0 : err:
812 : 0 : cleanup();
813 : 0 : return -1;
814 : : }
815 : :
816 : : static int
817 : 0 : test_load_balanced_traffic(void)
818 : : {
819 : : uint64_t timeout;
820 : 0 : struct rte_event_dev_config config = {0};
821 : : struct rte_event_queue_conf queue_conf;
822 : : struct rte_event_port_conf port_conf;
823 : : struct rte_event_dev_info info;
824 : : struct rte_event ev;
825 : : uint8_t queue_id;
826 : : int ret;
827 : :
828 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
829 : : printf("%d: Error querying device info\n", __LINE__);
830 : 0 : return -1;
831 : : }
832 : :
833 : 0 : config.nb_event_queues = 1;
834 : 0 : config.nb_event_ports = 1;
835 : 0 : config.nb_single_link_event_port_queues = 0;
836 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
837 : 0 : config.nb_events_limit = info.max_num_events;
838 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
839 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
840 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
841 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
842 : :
843 : : /* Configure the device with 1 LDB port and queue */
844 : 0 : ret = rte_event_dev_configure(evdev, &config);
845 [ # # ]: 0 : if (ret < 0) {
846 : : printf("%d: Error configuring device\n", __LINE__);
847 : 0 : return -1;
848 : : }
849 : :
850 : : /* Configure the ports and queues */
851 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
852 : : printf("%d: Error querying default port conf\n", __LINE__);
853 : 0 : goto err;
854 : : }
855 : :
856 [ # # ]: 0 : if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
857 : : printf("%d: port 0 setup expected to succeed\n",
858 : : __LINE__);
859 : 0 : goto err;
860 : : }
861 : :
862 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
863 : : printf("%d: Error querying default queue conf\n", __LINE__);
864 : 0 : goto err;
865 : : }
866 : :
867 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
868 : : printf("%d: queue 0 setup expected to succeed\n",
869 : : __LINE__);
870 : 0 : goto err;
871 : : }
872 : :
873 : : /* Link P0->Q0 */
874 : 0 : queue_id = 0;
875 : :
876 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
877 : : printf("%d: port 0 link expected to succeed\n",
878 : : __LINE__);
879 : 0 : goto err;
880 : : }
881 : :
882 : : /* Start the device */
883 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
884 : : printf("%d: device start failed\n", __LINE__);
885 : 0 : goto err;
886 : : }
887 : :
888 : : /* Enqueue 1 NEW event */
889 : 0 : ev.op = RTE_EVENT_OP_NEW;
890 : 0 : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
891 : 0 : ev.queue_id = 0;
892 : 0 : ev.priority = 0;
893 : 0 : ev.u64 = 0;
894 : :
895 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
896 : : printf("%d: NEW enqueue expected to succeed\n",
897 : : __LINE__);
898 : 0 : goto err;
899 : : }
900 : :
901 : : /* Dequeue and enqueue 1 FORWARD event */
902 : : timeout = 0xFFFFFFFFF;
903 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
904 : : printf("%d: event dequeue expected to succeed\n",
905 : : __LINE__);
906 : 0 : goto err;
907 : : }
908 : :
909 : 0 : ev.op = RTE_EVENT_OP_FORWARD;
910 : :
911 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
912 : : printf("%d: NEW enqueue expected to succeed\n",
913 : : __LINE__);
914 : 0 : goto err;
915 : : }
916 : :
917 : : /* Dequeue and enqueue 1 RELEASE operation */
918 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
919 : : printf("%d: event dequeue expected to succeed\n",
920 : : __LINE__);
921 : 0 : goto err;
922 : : }
923 : :
924 : 0 : ev.op = RTE_EVENT_OP_RELEASE;
925 : :
926 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
927 : : printf("%d: NEW enqueue expected to succeed\n",
928 : : __LINE__);
929 : 0 : goto err;
930 : : }
931 : :
932 : 0 : cleanup();
933 : 0 : return 0;
934 : :
935 : 0 : err:
936 : 0 : cleanup();
937 : 0 : return -1;
938 : : }
939 : :
940 : : static int
941 : 0 : test_directed_traffic(void)
942 : : {
943 : : uint64_t timeout;
944 : 0 : struct rte_event_dev_config config = {0};
945 : : struct rte_event_queue_conf queue_conf;
946 : : struct rte_event_port_conf port_conf;
947 : : struct rte_event_dev_info info;
948 : : struct rte_event ev;
949 : : uint8_t queue_id;
950 : : int ret;
951 : :
952 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
953 : : printf("%d: Error querying device info\n", __LINE__);
954 : 0 : return -1;
955 : : }
956 : :
957 : 0 : config.nb_event_queues = 1;
958 : 0 : config.nb_event_ports = 1;
959 : 0 : config.nb_single_link_event_port_queues = 1;
960 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
961 : 0 : config.nb_events_limit = info.max_num_events;
962 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
963 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
964 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
965 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
966 : :
967 : : /* Configure the device with 1 DIR port and queue */
968 : 0 : ret = rte_event_dev_configure(evdev, &config);
969 [ # # ]: 0 : if (ret < 0) {
970 : : printf("%d: Error configuring device\n", __LINE__);
971 : 0 : return -1;
972 : : }
973 : :
974 : : /* Configure the ports and queues */
975 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
976 : : printf("%d: Error querying default port conf\n", __LINE__);
977 : 0 : goto err;
978 : : }
979 : :
980 : 0 : port_conf.event_port_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
981 : :
982 [ # # ]: 0 : if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
983 : : printf("%d: port 0 setup expected to succeed\n",
984 : : __LINE__);
985 : 0 : goto err;
986 : : }
987 : :
988 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
989 : : printf("%d: Error querying default queue conf\n", __LINE__);
990 : 0 : goto err;
991 : : }
992 : :
993 : 0 : queue_conf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
994 : :
995 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
996 : : printf("%d: queue 0 setup expected to succeed\n",
997 : : __LINE__);
998 : 0 : goto err;
999 : : }
1000 : :
1001 : : /* Link P0->Q0 */
1002 : 0 : queue_id = 0;
1003 : :
1004 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1005 : : printf("%d: port 0 link expected to succeed\n",
1006 : : __LINE__);
1007 : 0 : goto err;
1008 : : }
1009 : :
1010 : : /* Start the device */
1011 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
1012 : : printf("%d: device start failed\n", __LINE__);
1013 : 0 : goto err;
1014 : : }
1015 : :
1016 : : /* Enqueue 1 NEW event */
1017 : 0 : ev.op = RTE_EVENT_OP_NEW;
1018 : 0 : ev.queue_id = 0;
1019 : 0 : ev.priority = 0;
1020 : 0 : ev.u64 = 0;
1021 : :
1022 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1023 : : printf("%d: NEW enqueue expected to succeed\n",
1024 : : __LINE__);
1025 : 0 : goto err;
1026 : : }
1027 : :
1028 : : /* Dequeue and enqueue 1 FORWARD event */
1029 : : timeout = 0xFFFFFFFFF;
1030 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1031 : : printf("%d: event dequeue expected to succeed\n",
1032 : : __LINE__);
1033 : 0 : goto err;
1034 : : }
1035 : :
1036 [ # # ]: 0 : if (ev.queue_id != 0) {
1037 : 0 : printf("%d: invalid dequeued event queue ID (%d)\n",
1038 : : __LINE__, ev.queue_id);
1039 : 0 : goto err;
1040 : : }
1041 : :
1042 : 0 : ev.op = RTE_EVENT_OP_FORWARD;
1043 : :
1044 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1045 : : printf("%d: NEW enqueue expected to succeed\n",
1046 : : __LINE__);
1047 : 0 : goto err;
1048 : : }
1049 : :
1050 : : /* Dequeue and enqueue 1 RELEASE operation */
1051 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1052 : : printf("%d: event dequeue expected to succeed\n",
1053 : : __LINE__);
1054 : 0 : goto err;
1055 : : }
1056 : :
1057 : 0 : ev.op = RTE_EVENT_OP_RELEASE;
1058 : :
1059 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1060 : : printf("%d: NEW enqueue expected to succeed\n",
1061 : : __LINE__);
1062 : 0 : goto err;
1063 : : }
1064 : :
1065 : 0 : cleanup();
1066 : 0 : return 0;
1067 : :
1068 : 0 : err:
1069 : 0 : cleanup();
1070 : 0 : return -1;
1071 : : }
1072 : :
1073 : : static int
1074 : 0 : test_deferred_sched(void)
1075 : : {
1076 : : uint64_t timeout;
1077 : 0 : struct rte_event_dev_config config = {0};
1078 : : struct rte_event_queue_conf queue_conf;
1079 : : struct rte_event_port_conf port_conf;
1080 : : struct rte_event_dev_info info;
1081 : : const int num_events = 128;
1082 : : struct rte_event ev;
1083 : : uint8_t queue_id;
1084 : : int ret, i;
1085 : :
1086 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
1087 : : printf("%d: Error querying device info\n", __LINE__);
1088 : 0 : return -1;
1089 : : }
1090 : :
1091 : 0 : config.nb_event_queues = 1;
1092 : 0 : config.nb_event_ports = 2;
1093 : 0 : config.nb_single_link_event_port_queues = 0;
1094 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
1095 : 0 : config.nb_events_limit = info.max_num_events;
1096 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1097 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1098 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1099 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1100 : :
1101 : : /* Configure the device with 2 LDB ports and 1 queue */
1102 : 0 : ret = rte_event_dev_configure(evdev, &config);
1103 [ # # ]: 0 : if (ret < 0) {
1104 : : printf("%d: Error configuring device\n", __LINE__);
1105 : 0 : return -1;
1106 : : }
1107 : :
1108 : 0 : ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 0, DEFERRED_POP);
1109 [ # # ]: 0 : if (ret < 0) {
1110 : : printf("%d: Error setting deferred scheduling\n", __LINE__);
1111 : 0 : goto err;
1112 : : }
1113 : :
1114 : 0 : ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 1, DEFERRED_POP);
1115 [ # # ]: 0 : if (ret < 0) {
1116 : : printf("%d: Error setting deferred scheduling\n", __LINE__);
1117 : 0 : goto err;
1118 : : }
1119 : :
1120 : : /* Configure the ports and queues */
1121 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1122 : : printf("%d: Error querying default port conf\n", __LINE__);
1123 : 0 : goto err;
1124 : : }
1125 : :
1126 : 0 : port_conf.dequeue_depth = 1;
1127 : :
1128 [ # # ]: 0 : if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1129 : : printf("%d: port 0 setup expected to succeed\n",
1130 : : __LINE__);
1131 : 0 : goto err;
1132 : : }
1133 : :
1134 [ # # ]: 0 : if (rte_event_port_setup(evdev, 1, &port_conf) < 0) {
1135 : : printf("%d: port 1 setup expected to succeed\n",
1136 : : __LINE__);
1137 : 0 : goto err;
1138 : : }
1139 : :
1140 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1141 : : printf("%d: Error querying default queue conf\n", __LINE__);
1142 : 0 : goto err;
1143 : : }
1144 : :
1145 : 0 : queue_conf.schedule_type = RTE_SCHED_TYPE_PARALLEL;
1146 : 0 : queue_conf.nb_atomic_order_sequences = 0;
1147 : :
1148 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1149 : : printf("%d: queue 0 setup expected to succeed\n",
1150 : : __LINE__);
1151 : 0 : goto err;
1152 : : }
1153 : :
1154 : : /* Link P0->Q0 and P1->Q0 */
1155 : 0 : queue_id = 0;
1156 : :
1157 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1158 : : printf("%d: port 0 link expected to succeed\n",
1159 : : __LINE__);
1160 : 0 : goto err;
1161 : : }
1162 : :
1163 [ # # ]: 0 : if (rte_event_port_link(evdev, 1, &queue_id, NULL, 1) != 1) {
1164 : : printf("%d: port 1 link expected to succeed\n",
1165 : : __LINE__);
1166 : 0 : goto err;
1167 : : }
1168 : :
1169 : : /* Start the device */
1170 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
1171 : : printf("%d: device start failed\n", __LINE__);
1172 : 0 : goto err;
1173 : : }
1174 : :
1175 : : /* Enqueue 128 NEW events */
1176 : 0 : ev.op = RTE_EVENT_OP_NEW;
1177 : 0 : ev.sched_type = RTE_SCHED_TYPE_PARALLEL;
1178 : 0 : ev.queue_id = 0;
1179 : 0 : ev.priority = 0;
1180 : 0 : ev.u64 = 0;
1181 : :
1182 [ # # ]: 0 : for (i = 0; i < num_events; i++) {
1183 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1184 : : printf("%d: NEW enqueue expected to succeed\n",
1185 : : __LINE__);
1186 : 0 : goto err;
1187 : : }
1188 : : }
1189 : :
1190 : : /* Dequeue one event from port 0 */
1191 : : timeout = 0xFFFFFFFFF;
1192 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1193 : : printf("%d: event dequeue expected to succeed\n",
1194 : : __LINE__);
1195 : 0 : goto err;
1196 : : }
1197 : :
1198 : : /* Dequeue (and release) all other events from port 1. Deferred
1199 : : * scheduling ensures no other events are scheduled to port 0 without a
1200 : : * subsequent rte_event_dequeue_burst() call.
1201 : : */
1202 [ # # ]: 0 : for (i = 0; i < num_events - 1; i++) {
1203 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 1, &ev, 1, timeout) != 1) {
1204 : : printf("%d: event dequeue expected to succeed\n",
1205 : : __LINE__);
1206 : 0 : goto err;
1207 : : }
1208 : :
1209 : 0 : ev.op = RTE_EVENT_OP_RELEASE;
1210 : :
1211 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 1, &ev, 1) != 1) {
1212 : : printf("%d: RELEASE enqueue expected to succeed\n",
1213 : : __LINE__);
1214 : 0 : goto err;
1215 : : }
1216 : : }
1217 : :
1218 : 0 : cleanup();
1219 : 0 : return 0;
1220 : :
1221 : 0 : err:
1222 : 0 : cleanup();
1223 : 0 : return -1;
1224 : : }
1225 : :
1226 : : static int
1227 : 0 : test_delayed_pop(void)
1228 : : {
1229 : : uint64_t timeout;
1230 : 0 : struct rte_event_dev_config config = {0};
1231 : : struct rte_event_queue_conf queue_conf;
1232 : : struct rte_event_port_conf port_conf;
1233 : : struct rte_event_dev_info info;
1234 : : int ret, i, num_events;
1235 : : struct rte_event ev;
1236 : : uint8_t queue_id;
1237 : :
1238 [ # # ]: 0 : if (rte_event_dev_info_get(evdev, &info)) {
1239 : : printf("%d: Error querying device info\n", __LINE__);
1240 : 0 : return -1;
1241 : : }
1242 : :
1243 : 0 : config.nb_event_queues = 1;
1244 : 0 : config.nb_event_ports = 1;
1245 : 0 : config.nb_single_link_event_port_queues = 0;
1246 : 0 : config.nb_event_queue_flows = info.max_event_queue_flows;
1247 : 0 : config.nb_events_limit = info.max_num_events;
1248 : 0 : config.nb_event_port_dequeue_depth = info.max_event_port_dequeue_depth;
1249 : 0 : config.nb_event_port_enqueue_depth = info.max_event_port_enqueue_depth;
1250 : 0 : config.dequeue_timeout_ns = info.max_dequeue_timeout_ns;
1251 : 0 : config.event_dev_cfg = RTE_EVENT_DEV_CFG_PER_DEQUEUE_TIMEOUT;
1252 : :
1253 : : /* Configure the device with 1 LDB port and queue */
1254 : 0 : ret = rte_event_dev_configure(evdev, &config);
1255 [ # # ]: 0 : if (ret < 0) {
1256 : : printf("%d: Error configuring device\n", __LINE__);
1257 : 0 : return -1;
1258 : : }
1259 : :
1260 : 0 : ret = rte_pmd_dlb2_set_token_pop_mode(evdev, 0, DELAYED_POP);
1261 [ # # ]: 0 : if (ret < 0) {
1262 : : printf("%d: Error setting deferred scheduling\n", __LINE__);
1263 : 0 : goto err;
1264 : : }
1265 : :
1266 : : /* Configure the ports and queues */
1267 [ # # ]: 0 : if (rte_event_port_default_conf_get(evdev, 0, &port_conf)) {
1268 : : printf("%d: Error querying default port conf\n", __LINE__);
1269 : 0 : goto err;
1270 : : }
1271 : :
1272 : 0 : port_conf.event_port_cfg = RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL;
1273 : :
1274 [ # # ]: 0 : if (rte_event_port_setup(evdev, 0, &port_conf) < 0) {
1275 : : printf("%d: port 0 setup expected to succeed\n",
1276 : : __LINE__);
1277 : 0 : goto err;
1278 : : }
1279 : :
1280 [ # # ]: 0 : if (rte_event_queue_default_conf_get(evdev, 0, &queue_conf)) {
1281 : : printf("%d: Error querying default queue conf\n", __LINE__);
1282 : 0 : goto err;
1283 : : }
1284 : :
1285 [ # # ]: 0 : if (rte_event_queue_setup(evdev, 0, &queue_conf) < 0) {
1286 : : printf("%d: queue 0 setup expected to succeed\n",
1287 : : __LINE__);
1288 : 0 : goto err;
1289 : : }
1290 : :
1291 : : /* Link P0->Q0 */
1292 : 0 : queue_id = 0;
1293 : :
1294 [ # # ]: 0 : if (rte_event_port_link(evdev, 0, &queue_id, NULL, 1) != 1) {
1295 : : printf("%d: port 0 link expected to succeed\n",
1296 : : __LINE__);
1297 : 0 : goto err;
1298 : : }
1299 : :
1300 : : /* Start the device */
1301 [ # # ]: 0 : if (rte_event_dev_start(evdev) < 0) {
1302 : : printf("%d: device start failed\n", __LINE__);
1303 : 0 : goto err;
1304 : : }
1305 : :
1306 : 0 : num_events = 2 * port_conf.dequeue_depth;
1307 : :
1308 : : /* Enqueue 2 * dequeue_depth NEW events */
1309 : 0 : ev.op = RTE_EVENT_OP_NEW;
1310 : 0 : ev.sched_type = RTE_SCHED_TYPE_ATOMIC;
1311 : 0 : ev.queue_id = 0;
1312 : 0 : ev.priority = 0;
1313 : 0 : ev.u64 = 0;
1314 : :
1315 [ # # ]: 0 : for (i = 0; i < num_events; i++) {
1316 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1317 : : printf("%d: NEW enqueue expected to succeed\n",
1318 : : __LINE__);
1319 : 0 : goto err;
1320 : : }
1321 : : }
1322 : :
1323 : : /* Dequeue dequeue_depth events but only release dequeue_depth - 1.
1324 : : * Delayed pop won't perform the pop and no more events will be
1325 : : * scheduled.
1326 : : */
1327 : : timeout = 0xFFFFFFFFF;
1328 : :
1329 [ # # ]: 0 : for (i = 0; i < port_conf.dequeue_depth; i++) {
1330 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1331 : : printf("%d: event dequeue expected to succeed\n",
1332 : : __LINE__);
1333 : 0 : goto err;
1334 : : }
1335 : : }
1336 : :
1337 : 0 : ev.op = RTE_EVENT_OP_RELEASE;
1338 : :
1339 [ # # ]: 0 : for (i = 0; i < port_conf.dequeue_depth - 1; i++) {
1340 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1341 : : printf("%d: RELEASE enqueue expected to succeed\n",
1342 : : __LINE__);
1343 : 0 : goto err;
1344 : : }
1345 : : }
1346 : :
1347 : : timeout = 0x10000;
1348 : :
1349 : 0 : ret = rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout);
1350 [ # # ]: 0 : if (ret != 0) {
1351 : : printf("%d: event dequeue expected to fail (ret = %d)\n",
1352 : : __LINE__, ret);
1353 : 0 : goto err;
1354 : : }
1355 : :
1356 : : /* Release one more event. This will trigger the token pop, and
1357 : : * dequeue_depth more events will be scheduled to the device.
1358 : : */
1359 : 0 : ev.op = RTE_EVENT_OP_RELEASE;
1360 : :
1361 [ # # ]: 0 : if (rte_event_enqueue_burst(evdev, 0, &ev, 1) != 1) {
1362 : : printf("%d: RELEASE enqueue expected to succeed\n",
1363 : : __LINE__);
1364 : 0 : goto err;
1365 : : }
1366 : :
1367 : : timeout = 0xFFFFFFFFF;
1368 : :
1369 [ # # ]: 0 : for (i = 0; i < port_conf.dequeue_depth; i++) {
1370 [ # # ]: 0 : if (rte_event_dequeue_burst(evdev, 0, &ev, 1, timeout) != 1) {
1371 : : printf("%d: event dequeue expected to succeed\n",
1372 : : __LINE__);
1373 : 0 : goto err;
1374 : : }
1375 : : }
1376 : :
1377 : 0 : cleanup();
1378 : 0 : return 0;
1379 : :
1380 : 0 : err:
1381 : 0 : cleanup();
1382 : 0 : return -1;
1383 : : }
1384 : :
1385 : : static int
1386 : 0 : do_selftest(void)
1387 : : {
1388 : : struct test t;
1389 : : int ret;
1390 : :
1391 : : /* Only create mbuf pool once, reuse for each test run */
1392 [ # # ]: 0 : if (!eventdev_func_mempool) {
1393 : 0 : eventdev_func_mempool =
1394 : 0 : rte_pktmbuf_pool_create("EVENTDEV_DLB2_ST_POOL",
1395 : : (1 << 12), /* 4k buffers */
1396 : : 32 /*MBUF_CACHE_SIZE*/,
1397 : : 0,
1398 : : 512, /* use very small mbufs */
1399 : 0 : rte_socket_id());
1400 [ # # ]: 0 : if (!eventdev_func_mempool) {
1401 : : printf("ERROR creating mempool\n");
1402 : 0 : goto test_fail;
1403 : : }
1404 : : }
1405 : 0 : t.mbuf_pool = eventdev_func_mempool;
1406 : :
1407 : : printf("*** Running Stop Flush test...\n");
1408 : 0 : ret = test_stop_flush(&t);
1409 [ # # ]: 0 : if (ret != 0) {
1410 : : printf("ERROR - Stop Flush test FAILED.\n");
1411 : 0 : return ret;
1412 : : }
1413 : :
1414 : : printf("*** Running Single Link test...\n");
1415 : 0 : ret = test_single_link();
1416 [ # # ]: 0 : if (ret != 0) {
1417 : : printf("ERROR - Single Link test FAILED.\n");
1418 : :
1419 : 0 : goto test_fail;
1420 : : }
1421 : :
1422 : : printf("*** Running Info Get test...\n");
1423 : 0 : ret = test_info_get();
1424 [ # # ]: 0 : if (ret != 0) {
1425 : : printf("ERROR - Stop Flush test FAILED.\n");
1426 : 0 : return ret;
1427 : : }
1428 : :
1429 : : printf("*** Running Reconfiguration Link test...\n");
1430 : 0 : ret = test_reconfiguration_link();
1431 [ # # ]: 0 : if (ret != 0) {
1432 : : printf("ERROR - Reconfiguration Link test FAILED.\n");
1433 : :
1434 : 0 : goto test_fail;
1435 : : }
1436 : :
1437 : : printf("*** Running Load-Balanced Traffic test...\n");
1438 : 0 : ret = test_load_balanced_traffic();
1439 [ # # ]: 0 : if (ret != 0) {
1440 : : printf("ERROR - Load-Balanced Traffic test FAILED.\n");
1441 : :
1442 : 0 : goto test_fail;
1443 : : }
1444 : :
1445 : : printf("*** Running Directed Traffic test...\n");
1446 : 0 : ret = test_directed_traffic();
1447 [ # # ]: 0 : if (ret != 0) {
1448 : : printf("ERROR - Directed Traffic test FAILED.\n");
1449 : :
1450 : 0 : goto test_fail;
1451 : : }
1452 : :
1453 : : printf("*** Running Deferred Scheduling test...\n");
1454 : 0 : ret = test_deferred_sched();
1455 [ # # ]: 0 : if (ret != 0) {
1456 : : printf("ERROR - Deferred Scheduling test FAILED.\n");
1457 : :
1458 : 0 : goto test_fail;
1459 : : }
1460 : :
1461 : : printf("*** Running Delayed Pop test...\n");
1462 : 0 : ret = test_delayed_pop();
1463 [ # # ]: 0 : if (ret != 0) {
1464 : : printf("ERROR - Delayed Pop test FAILED.\n");
1465 : :
1466 : 0 : goto test_fail;
1467 : : }
1468 : :
1469 : : return 0;
1470 : :
1471 : : test_fail:
1472 : : return -1;
1473 : : }
1474 : :
1475 : : int
1476 : 0 : test_dlb2_eventdev(void)
1477 : : {
1478 : : const char *dlb2_eventdev_name = "event_dlb2";
1479 : 0 : uint8_t num_evdevs = rte_event_dev_count();
1480 : : int i, ret = 0;
1481 : : int found = 0, skipped = 0, passed = 0, failed = 0;
1482 : : struct rte_event_dev_info info;
1483 : :
1484 [ # # # # ]: 0 : for (i = 0; found + skipped < num_evdevs && i < RTE_EVENT_MAX_DEVS;
1485 : 0 : i++) {
1486 : 0 : ret = rte_event_dev_info_get(i, &info);
1487 [ # # ]: 0 : if (ret < 0)
1488 : 0 : continue;
1489 : :
1490 : : /* skip non-dlb2 event devices */
1491 [ # # ]: 0 : if (strncmp(info.driver_name, dlb2_eventdev_name,
1492 : : strlen(dlb2_eventdev_name)) != 0) {
1493 : 0 : skipped++;
1494 : 0 : continue;
1495 : : }
1496 : :
1497 : 0 : evdev = rte_event_dev_get_dev_id(info.driver_name);
1498 [ # # ]: 0 : if (evdev < 0) {
1499 : 0 : printf("Could not get dev_id for eventdev with name %s, i=%d\n",
1500 : : info.driver_name, i);
1501 : 0 : skipped++;
1502 : 0 : continue;
1503 : : }
1504 : 0 : found++;
1505 : 0 : printf("Running selftest on eventdev %s\n", info.driver_name);
1506 : 0 : ret = do_selftest();
1507 [ # # ]: 0 : if (ret == 0) {
1508 : 0 : passed++;
1509 : 0 : printf("Selftest passed for eventdev %s\n",
1510 : : info.driver_name);
1511 : : } else {
1512 : 0 : failed++;
1513 : 0 : printf("Selftest failed for eventdev %s, err=%d\n",
1514 : : info.driver_name, ret);
1515 : : }
1516 : : }
1517 : :
1518 : : printf("Ran selftest on %d eventdevs, %d skipped, %d passed, %d failed\n",
1519 : : found, skipped, passed, failed);
1520 : 0 : return ret;
1521 : : }
|
