Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright(c) 2016 Cavium, Inc
3 : : */
4 : :
5 : : #include "test.h"
6 : :
7 : : #include <rte_common.h>
8 : : #include <rte_hexdump.h>
9 : : #include <rte_mbuf.h>
10 : : #include <rte_malloc.h>
11 : : #include <rte_memcpy.h>
12 : :
13 : : #ifdef RTE_EXEC_ENV_WINDOWS
14 : : static int
15 : : test_eventdev_common(void)
16 : : {
17 : : printf("eventdev_common not supported on Windows, skipping test\n");
18 : : return TEST_SKIPPED;
19 : : }
20 : :
21 : : #else
22 : :
23 : : #include <rte_eventdev.h>
24 : : #include <rte_dev.h>
25 : : #include <rte_bus_vdev.h>
26 : :
27 : : #define TEST_DEV_ID 0
28 : :
29 : : static int
30 : 1 : testsuite_setup(void)
31 : : {
32 : : RTE_BUILD_BUG_ON(sizeof(struct rte_event) != 16);
33 : : uint8_t count;
34 : 1 : count = rte_event_dev_count();
35 [ + - ]: 1 : if (!count) {
36 : : printf("Failed to find a valid event device,"
37 : : " testing with event_skeleton device\n");
38 : 1 : return rte_vdev_init("event_skeleton", NULL);
39 : : }
40 : : return TEST_SUCCESS;
41 : : }
42 : :
43 : : static void
44 : 1 : testsuite_teardown(void)
45 : : {
46 : 1 : }
47 : :
48 : : static int
49 : 1 : test_eventdev_count(void)
50 : : {
51 : : uint8_t count;
52 : 1 : count = rte_event_dev_count();
53 [ - + ]: 1 : TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count);
54 : : return TEST_SUCCESS;
55 : : }
56 : :
57 : : static int
58 : 1 : test_eventdev_get_dev_id(void)
59 : : {
60 : : int ret;
61 : 1 : ret = rte_event_dev_get_dev_id("not_a_valid_eventdev_driver");
62 [ - + ]: 1 : TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret);
63 : : return TEST_SUCCESS;
64 : : }
65 : :
66 : : static int
67 : 1 : test_eventdev_socket_id(void)
68 : : {
69 : : int socket_id;
70 : 1 : socket_id = rte_event_dev_socket_id(TEST_DEV_ID);
71 [ - + ]: 1 : TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d",
72 : : socket_id);
73 : 1 : socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS);
74 [ - + ]: 1 : TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id);
75 : :
76 : : return TEST_SUCCESS;
77 : : }
78 : :
79 : : static int
80 : 1 : test_eventdev_info_get(void)
81 : : {
82 : : int ret;
83 : : struct rte_event_dev_info info;
84 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, NULL);
85 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
86 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
87 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
88 [ - + ]: 1 : TEST_ASSERT(info.max_event_ports > 0,
89 : : "Not enough event ports %d", info.max_event_ports);
90 [ - + ]: 1 : TEST_ASSERT(info.max_event_queues > 0,
91 : : "Not enough event queues %d", info.max_event_queues);
92 : : return TEST_SUCCESS;
93 : : }
94 : :
95 : : static inline void
96 : 33 : devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
97 : : struct rte_event_dev_info *info)
98 : : {
99 : : memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
100 : 33 : dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
101 : 33 : dev_conf->nb_event_ports = info->max_event_ports;
102 : 33 : dev_conf->nb_event_queues = info->max_event_queues;
103 : 33 : dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
104 : 33 : dev_conf->nb_event_port_dequeue_depth =
105 : 33 : info->max_event_port_dequeue_depth;
106 : 33 : dev_conf->nb_event_port_enqueue_depth =
107 : 33 : info->max_event_port_enqueue_depth;
108 : : dev_conf->nb_event_port_enqueue_depth =
109 : : info->max_event_port_enqueue_depth;
110 : 33 : dev_conf->nb_events_limit =
111 : 33 : info->max_num_events;
112 : 33 : }
113 : :
114 : : static int
115 : 7 : test_ethdev_config_run(struct rte_event_dev_config *dev_conf,
116 : : struct rte_event_dev_info *info,
117 : : void (*fn)(struct rte_event_dev_config *dev_conf,
118 : : struct rte_event_dev_info *info))
119 : : {
120 : 7 : devconf_set_default_sane_values(dev_conf, info);
121 : 7 : fn(dev_conf, info);
122 : 7 : return rte_event_dev_configure(TEST_DEV_ID, dev_conf);
123 : : }
124 : :
125 : : static void
126 : 1 : max_dequeue_limit(struct rte_event_dev_config *dev_conf,
127 : : struct rte_event_dev_info *info)
128 : : {
129 : 1 : dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
130 : 1 : }
131 : :
132 : : static void
133 : 1 : max_events_limit(struct rte_event_dev_config *dev_conf,
134 : : struct rte_event_dev_info *info)
135 : : {
136 : 1 : dev_conf->nb_events_limit = info->max_num_events + 1;
137 : 1 : }
138 : :
139 : : static void
140 : 1 : max_event_ports(struct rte_event_dev_config *dev_conf,
141 : : struct rte_event_dev_info *info)
142 : : {
143 : 1 : dev_conf->nb_event_ports = info->max_event_ports + 1;
144 : 1 : }
145 : :
146 : : static void
147 : 1 : max_event_queues(struct rte_event_dev_config *dev_conf,
148 : : struct rte_event_dev_info *info)
149 : : {
150 : 1 : dev_conf->nb_event_queues = info->max_event_queues + 1;
151 : 1 : }
152 : :
153 : : static void
154 : 1 : max_event_queue_flows(struct rte_event_dev_config *dev_conf,
155 : : struct rte_event_dev_info *info)
156 : : {
157 : 1 : dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
158 : 1 : }
159 : :
160 : : static void
161 : 1 : max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
162 : : struct rte_event_dev_info *info)
163 : : {
164 : 1 : dev_conf->nb_event_port_dequeue_depth =
165 : 1 : info->max_event_port_dequeue_depth + 1;
166 : 1 : }
167 : :
168 : : static void
169 : 1 : max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
170 : : struct rte_event_dev_info *info)
171 : : {
172 : 1 : dev_conf->nb_event_port_enqueue_depth =
173 : 1 : info->max_event_port_enqueue_depth + 1;
174 : 1 : }
175 : :
176 : :
177 : : static int
178 : 1 : test_eventdev_configure(void)
179 : : {
180 : : int ret;
181 : : struct rte_event_dev_config dev_conf;
182 : : struct rte_event_dev_info info;
183 : 1 : ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
184 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
185 : :
186 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
187 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
188 : :
189 : : /* Check limits */
190 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
191 : : test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
192 : : "Config negative test failed");
193 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
194 : : test_ethdev_config_run(&dev_conf, &info, max_events_limit),
195 : : "Config negative test failed");
196 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
197 : : test_ethdev_config_run(&dev_conf, &info, max_event_ports),
198 : : "Config negative test failed");
199 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
200 : : test_ethdev_config_run(&dev_conf, &info, max_event_queues),
201 : : "Config negative test failed");
202 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
203 : : test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
204 : : "Config negative test failed");
205 : :
206 [ + - ]: 1 : if (info.event_dev_cap & RTE_EVENT_DEV_CAP_BURST_MODE) {
207 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
208 : : test_ethdev_config_run(&dev_conf, &info,
209 : : max_event_port_dequeue_depth),
210 : : "Config negative test failed");
211 [ - + ]: 1 : TEST_ASSERT_EQUAL(-EINVAL,
212 : : test_ethdev_config_run(&dev_conf, &info,
213 : : max_event_port_enqueue_depth),
214 : : "Config negative test failed");
215 : : }
216 : :
217 : : /* Positive case */
218 : 1 : devconf_set_default_sane_values(&dev_conf, &info);
219 : 1 : ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
220 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
221 : :
222 : : /* re-configure */
223 : 1 : devconf_set_default_sane_values(&dev_conf, &info);
224 : 1 : dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
225 : 1 : dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
226 : 1 : ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
227 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
228 : :
229 : : /* re-configure back to max_event_queues and max_event_ports */
230 : 1 : devconf_set_default_sane_values(&dev_conf, &info);
231 : 1 : ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
232 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
233 : :
234 : : return TEST_SUCCESS;
235 : :
236 : : }
237 : :
238 : : static int
239 : 23 : eventdev_configure_setup(void)
240 : : {
241 : : int ret;
242 : : struct rte_event_dev_config dev_conf;
243 : : struct rte_event_dev_info info;
244 : :
245 : 23 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
246 [ - + ]: 23 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
247 : 23 : devconf_set_default_sane_values(&dev_conf, &info);
248 : 23 : ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
249 [ - + ]: 23 : TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
250 : :
251 : : return TEST_SUCCESS;
252 : : }
253 : :
254 : : static int
255 : 1 : test_eventdev_queue_default_conf_get(void)
256 : : {
257 : : int i, ret;
258 : : struct rte_event_queue_conf qconf;
259 : :
260 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
261 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
262 : :
263 : : uint32_t queue_count;
264 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
265 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
266 : : "Queue count get failed");
267 : :
268 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
269 : 64 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
270 : : &qconf);
271 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
272 : : }
273 : :
274 : : return TEST_SUCCESS;
275 : : }
276 : :
277 : : static int
278 : 1 : test_eventdev_queue_setup(void)
279 : : {
280 : : int i, ret;
281 : : struct rte_event_dev_info info;
282 : : struct rte_event_queue_conf qconf;
283 : :
284 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
285 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
286 : :
287 : : /* Negative cases */
288 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
289 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
290 : 1 : qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
291 : 1 : qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
292 : 1 : ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
293 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
294 : :
295 : 1 : qconf.nb_atomic_flows = info.max_event_queue_flows;
296 : 1 : qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
297 : 1 : qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
298 : 1 : ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
299 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
300 : :
301 : 1 : ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
302 : : &qconf);
303 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
304 : :
305 : : /* Positive case */
306 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
307 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
308 : 1 : ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
309 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
310 : :
311 : : uint32_t queue_count;
312 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
313 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
314 : : "Queue count get failed");
315 : :
316 [ + + ]: 64 : for (i = 1; i < (int)queue_count; i++) {
317 : 63 : ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
318 [ - + ]: 63 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
319 : : }
320 : :
321 : : return TEST_SUCCESS;
322 : : }
323 : :
324 : : static int
325 : 1 : test_eventdev_queue_count(void)
326 : : {
327 : : int ret;
328 : : struct rte_event_dev_info info;
329 : :
330 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
331 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
332 : :
333 : : uint32_t queue_count;
334 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
335 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
336 : : "Queue count get failed");
337 [ - + ]: 1 : TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
338 : : "Wrong queue count");
339 : :
340 : : return TEST_SUCCESS;
341 : : }
342 : :
343 : : static int
344 : 1 : test_eventdev_queue_attr_priority(void)
345 : : {
346 : : int i, ret;
347 : : struct rte_event_dev_info info;
348 : : struct rte_event_queue_conf qconf;
349 : : uint8_t priority;
350 : :
351 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
352 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
353 : :
354 : : uint32_t queue_count;
355 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
356 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
357 : : "Queue count get failed");
358 : :
359 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
360 : 64 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
361 : : &qconf);
362 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
363 : 64 : qconf.priority = i % RTE_EVENT_DEV_PRIORITY_LOWEST;
364 : 64 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
365 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
366 : : }
367 : :
368 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
369 : : uint32_t tmp;
370 [ - + ]: 64 : TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
371 : : RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
372 : : "Queue priority get failed");
373 : 64 : priority = tmp;
374 : :
375 [ + - ]: 64 : if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
376 [ - + ]: 64 : TEST_ASSERT_EQUAL(priority,
377 : : i % RTE_EVENT_DEV_PRIORITY_LOWEST,
378 : : "Wrong priority value for queue%d", i);
379 : : else
380 [ # # ]: 0 : TEST_ASSERT_EQUAL(priority,
381 : : RTE_EVENT_DEV_PRIORITY_NORMAL,
382 : : "Wrong priority value for queue%d", i);
383 : : }
384 : :
385 : : return TEST_SUCCESS;
386 : : }
387 : :
388 : : static int
389 : 1 : test_eventdev_queue_attr_priority_runtime(void)
390 : : {
391 : : uint32_t queue_count, queue_req, prio, deq_cnt;
392 : : struct rte_event_queue_conf qconf;
393 : : struct rte_event_port_conf pconf;
394 : : struct rte_event_dev_info info;
395 : 1 : struct rte_event event = {
396 : : .op = RTE_EVENT_OP_NEW,
397 : : .event_type = RTE_EVENT_TYPE_CPU,
398 : : .sched_type = RTE_SCHED_TYPE_ATOMIC,
399 : : .u64 = 0xbadbadba,
400 : : };
401 : : int i, ret;
402 : :
403 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
404 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
405 : :
406 [ - + ]: 1 : if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
407 : : return TEST_SKIPPED;
408 : :
409 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
410 : : TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
411 : : &queue_count),
412 : : "Queue count get failed");
413 : :
414 : : /* Need at least 2 queues to test LOW and HIGH priority. */
415 [ # # ]: 0 : TEST_ASSERT(queue_count > 1, "Not enough event queues, needed 2");
416 : : queue_req = 2;
417 : :
418 [ # # ]: 0 : for (i = 0; i < (int)queue_count; i++) {
419 : 0 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
420 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
421 : 0 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
422 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
423 : : }
424 : :
425 : 0 : ret = rte_event_queue_attr_set(TEST_DEV_ID, 0,
426 : : RTE_EVENT_QUEUE_ATTR_PRIORITY,
427 : : RTE_EVENT_DEV_PRIORITY_LOWEST);
428 [ # # ]: 0 : if (ret == -ENOTSUP)
429 : : return TEST_SKIPPED;
430 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue0 priority set failed");
431 : :
432 : 0 : ret = rte_event_queue_attr_set(TEST_DEV_ID, 1,
433 : : RTE_EVENT_QUEUE_ATTR_PRIORITY,
434 : : RTE_EVENT_DEV_PRIORITY_HIGHEST);
435 [ # # ]: 0 : if (ret == -ENOTSUP)
436 : : return TEST_SKIPPED;
437 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue1 priority set failed");
438 : :
439 : : /* Setup event port 0 */
440 : 0 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
441 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
442 : 0 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
443 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
444 : 0 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
445 [ # # ]: 0 : TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
446 : : TEST_DEV_ID);
447 : :
448 : 0 : ret = rte_event_dev_start(TEST_DEV_ID);
449 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
450 : :
451 [ # # ]: 0 : for (i = 0; i < (int)queue_req; i++) {
452 : 0 : event.queue_id = i;
453 [ # # ]: 0 : while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1)
454 : : rte_pause();
455 : : }
456 : :
457 : : prio = RTE_EVENT_DEV_PRIORITY_HIGHEST;
458 : : deq_cnt = 0;
459 [ # # ]: 0 : while (deq_cnt < queue_req) {
460 : : uint32_t queue_prio;
461 : :
462 [ # # ]: 0 : if (rte_event_dequeue_burst(TEST_DEV_ID, 0, &event, 1, 0) == 0)
463 : 0 : continue;
464 : :
465 : 0 : ret = rte_event_queue_attr_get(TEST_DEV_ID, event.queue_id,
466 : : RTE_EVENT_QUEUE_ATTR_PRIORITY,
467 : : &queue_prio);
468 [ # # ]: 0 : if (ret == -ENOTSUP)
469 : 0 : return TEST_SKIPPED;
470 : :
471 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue priority get failed");
472 [ # # ]: 0 : TEST_ASSERT(queue_prio >= prio,
473 : : "Received event from a lower priority queue first");
474 : : prio = queue_prio;
475 : 0 : deq_cnt++;
476 : : }
477 : :
478 : : return TEST_SUCCESS;
479 : : }
480 : :
481 : : static int
482 : 1 : test_eventdev_queue_attr_weight_runtime(void)
483 : : {
484 : : struct rte_event_queue_conf qconf;
485 : : struct rte_event_dev_info info;
486 : : uint32_t queue_count;
487 : : int i, ret;
488 : :
489 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
490 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
491 : :
492 [ - + ]: 1 : if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
493 : : return TEST_SKIPPED;
494 : :
495 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
496 : : TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
497 : : &queue_count),
498 : : "Queue count get failed");
499 : :
500 [ # # ]: 0 : for (i = 0; i < (int)queue_count; i++) {
501 : 0 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
502 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
503 : 0 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
504 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
505 : : }
506 : :
507 [ # # ]: 0 : for (i = 0; i < (int)queue_count; i++) {
508 : : uint32_t get_val;
509 : : uint64_t set_val;
510 : :
511 : 0 : set_val = i % RTE_EVENT_QUEUE_WEIGHT_HIGHEST;
512 : 0 : ret = rte_event_queue_attr_set(
513 : : TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_WEIGHT, set_val);
514 [ # # ]: 0 : if (ret == -ENOTSUP)
515 : 0 : return TEST_SKIPPED;
516 : :
517 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue weight set failed");
518 : :
519 : 0 : ret = rte_event_queue_attr_get(
520 : : TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_WEIGHT, &get_val);
521 [ # # ]: 0 : if (ret == -ENOTSUP)
522 : : return TEST_SKIPPED;
523 : :
524 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue weight get failed");
525 [ # # ]: 0 : TEST_ASSERT_EQUAL(get_val, set_val,
526 : : "Wrong weight value for queue%d", i);
527 : : }
528 : :
529 : : return TEST_SUCCESS;
530 : : }
531 : :
532 : : static int
533 : 1 : test_eventdev_queue_attr_affinity_runtime(void)
534 : : {
535 : : struct rte_event_queue_conf qconf;
536 : : struct rte_event_dev_info info;
537 : : uint32_t queue_count;
538 : : int i, ret;
539 : :
540 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
541 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
542 : :
543 [ - + ]: 1 : if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
544 : : return TEST_SKIPPED;
545 : :
546 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
547 : : TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
548 : : &queue_count),
549 : : "Queue count get failed");
550 : :
551 [ # # ]: 0 : for (i = 0; i < (int)queue_count; i++) {
552 : 0 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
553 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
554 : 0 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
555 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
556 : : }
557 : :
558 [ # # ]: 0 : for (i = 0; i < (int)queue_count; i++) {
559 : : uint32_t get_val;
560 : : uint64_t set_val;
561 : :
562 : 0 : set_val = i % RTE_EVENT_QUEUE_AFFINITY_HIGHEST;
563 : 0 : ret = rte_event_queue_attr_set(
564 : : TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_AFFINITY, set_val);
565 [ # # ]: 0 : if (ret == -ENOTSUP)
566 : 0 : return TEST_SKIPPED;
567 : :
568 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue affinity set failed");
569 : :
570 : 0 : ret = rte_event_queue_attr_get(
571 : : TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_AFFINITY, &get_val);
572 [ # # ]: 0 : if (ret == -ENOTSUP)
573 : : return TEST_SKIPPED;
574 : :
575 [ # # ]: 0 : TEST_ASSERT_SUCCESS(ret, "Queue affinity get failed");
576 [ # # ]: 0 : TEST_ASSERT_EQUAL(get_val, set_val,
577 : : "Wrong affinity value for queue%d", i);
578 : : }
579 : :
580 : : return TEST_SUCCESS;
581 : : }
582 : :
583 : : static int
584 : 1 : test_eventdev_queue_attr_nb_atomic_flows(void)
585 : : {
586 : : int i, ret;
587 : : struct rte_event_dev_info info;
588 : : struct rte_event_queue_conf qconf;
589 : : uint32_t nb_atomic_flows;
590 : :
591 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
592 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
593 : :
594 : : uint32_t queue_count;
595 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
596 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
597 : : "Queue count get failed");
598 : :
599 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
600 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
601 : :
602 [ + - ]: 1 : if (qconf.nb_atomic_flows == 0)
603 : : /* Assume PMD doesn't support atomic flows, return early */
604 : : return -ENOTSUP;
605 : :
606 : 1 : qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
607 : :
608 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
609 : 64 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
610 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
611 : : }
612 : :
613 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
614 [ - + ]: 64 : TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
615 : : RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS,
616 : : &nb_atomic_flows),
617 : : "Queue nb_atomic_flows get failed");
618 : :
619 [ - + ]: 64 : TEST_ASSERT_EQUAL(nb_atomic_flows, qconf.nb_atomic_flows,
620 : : "Wrong atomic flows value for queue%d", i);
621 : : }
622 : :
623 : : return TEST_SUCCESS;
624 : : }
625 : :
626 : : static int
627 : 1 : test_eventdev_queue_attr_nb_atomic_order_sequences(void)
628 : : {
629 : : int i, ret;
630 : : struct rte_event_dev_info info;
631 : : struct rte_event_queue_conf qconf;
632 : : uint32_t nb_atomic_order_sequences;
633 : :
634 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
635 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
636 : :
637 : : uint32_t queue_count;
638 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
639 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
640 : : "Queue count get failed");
641 : :
642 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
643 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
644 : :
645 [ + - ]: 1 : if (qconf.nb_atomic_order_sequences == 0)
646 : : /* Assume PMD doesn't support reordering */
647 : : return -ENOTSUP;
648 : :
649 : 1 : qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
650 : :
651 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
652 : 64 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
653 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
654 : : }
655 : :
656 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
657 [ - + ]: 64 : TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
658 : : RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES,
659 : : &nb_atomic_order_sequences),
660 : : "Queue nb_atomic_order_sequencess get failed");
661 : :
662 [ - + ]: 64 : TEST_ASSERT_EQUAL(nb_atomic_order_sequences,
663 : : qconf.nb_atomic_order_sequences,
664 : : "Wrong atomic order sequences value for queue%d",
665 : : i);
666 : : }
667 : :
668 : : return TEST_SUCCESS;
669 : : }
670 : :
671 : : static int
672 : 1 : test_eventdev_queue_attr_event_queue_cfg(void)
673 : : {
674 : : int i, ret;
675 : : struct rte_event_dev_info info;
676 : : struct rte_event_queue_conf qconf;
677 : : uint32_t event_queue_cfg;
678 : :
679 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
680 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
681 : :
682 : : uint32_t queue_count;
683 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
684 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
685 : : "Queue count get failed");
686 : :
687 : 1 : ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
688 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 def conf");
689 : :
690 : 1 : qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
691 : :
692 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
693 : 64 : ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
694 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
695 : : }
696 : :
697 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
698 [ - + ]: 64 : TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
699 : : RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG,
700 : : &event_queue_cfg),
701 : : "Queue event_queue_cfg get failed");
702 : :
703 [ - + ]: 64 : TEST_ASSERT_EQUAL(event_queue_cfg, qconf.event_queue_cfg,
704 : : "Wrong event_queue_cfg value for queue%d",
705 : : i);
706 : : }
707 : :
708 : : return TEST_SUCCESS;
709 : : }
710 : :
711 : : static int
712 : 1 : test_eventdev_port_default_conf_get(void)
713 : : {
714 : : int i, ret;
715 : : struct rte_event_port_conf pconf;
716 : :
717 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
718 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
719 : :
720 : : uint32_t port_count;
721 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
722 : : RTE_EVENT_DEV_ATTR_PORT_COUNT,
723 : : &port_count), "Port count get failed");
724 : :
725 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID,
726 : 1 : port_count + 1, NULL);
727 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
728 : :
729 [ + + ]: 33 : for (i = 0; i < (int)port_count; i++) {
730 : 32 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
731 : : &pconf);
732 [ - + ]: 32 : TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
733 : : }
734 : :
735 : : return TEST_SUCCESS;
736 : : }
737 : :
738 : : static int
739 : 1 : test_eventdev_port_setup(void)
740 : : {
741 : : int i, ret;
742 : : struct rte_event_dev_info info;
743 : : struct rte_event_port_conf pconf;
744 : :
745 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
746 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
747 : :
748 : : /* Negative cases */
749 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
750 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
751 : 1 : pconf.new_event_threshold = info.max_num_events + 1;
752 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
753 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
754 : :
755 : 1 : pconf.new_event_threshold = info.max_num_events;
756 : 1 : pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
757 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
758 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
759 : :
760 : 1 : pconf.dequeue_depth = info.max_event_port_dequeue_depth;
761 : 1 : pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
762 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
763 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
764 : :
765 [ + - ]: 1 : if (!(info.event_dev_cap &
766 : : RTE_EVENT_DEV_CAP_IMPLICIT_RELEASE_DISABLE)) {
767 : 1 : pconf.enqueue_depth = info.max_event_port_enqueue_depth;
768 : 1 : pconf.event_port_cfg = RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL;
769 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
770 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
771 : 1 : pconf.event_port_cfg = 0;
772 : : }
773 : :
774 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
775 : : &pconf);
776 [ - + ]: 1 : TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
777 : :
778 : : /* Positive case */
779 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
780 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
781 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
782 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
783 : :
784 : : uint32_t port_count;
785 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
786 : : RTE_EVENT_DEV_ATTR_PORT_COUNT,
787 : : &port_count), "Port count get failed");
788 : :
789 [ + + ]: 32 : for (i = 1; i < (int)port_count; i++) {
790 : 31 : ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
791 [ - + ]: 31 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
792 : : }
793 : :
794 : : return TEST_SUCCESS;
795 : : }
796 : :
797 : : static int
798 : 1 : test_eventdev_port_attr_dequeue_depth(void)
799 : : {
800 : : int ret;
801 : : struct rte_event_dev_info info;
802 : : struct rte_event_port_conf pconf;
803 : :
804 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
805 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
806 : :
807 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
808 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
809 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
810 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
811 : :
812 : : uint32_t value;
813 [ - + ]: 1 : TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
814 : : RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
815 : : 0, "Call to get port dequeue depth failed");
816 [ - + ]: 1 : TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
817 : : "Wrong port dequeue depth");
818 : :
819 : : return TEST_SUCCESS;
820 : : }
821 : :
822 : : static int
823 : 1 : test_eventdev_port_attr_enqueue_depth(void)
824 : : {
825 : : int ret;
826 : : struct rte_event_dev_info info;
827 : : struct rte_event_port_conf pconf;
828 : :
829 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
830 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
831 : :
832 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
833 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
834 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
835 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
836 : :
837 : : uint32_t value;
838 [ - + ]: 1 : TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
839 : : RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
840 : : 0, "Call to get port enqueue depth failed");
841 [ - + ]: 1 : TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
842 : : "Wrong port enqueue depth");
843 : :
844 : : return TEST_SUCCESS;
845 : : }
846 : :
847 : : static int
848 : 1 : test_eventdev_port_attr_new_event_threshold(void)
849 : : {
850 : : int ret;
851 : : struct rte_event_dev_info info;
852 : : struct rte_event_port_conf pconf;
853 : :
854 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
855 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
856 : :
857 : 1 : ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
858 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
859 : 1 : ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
860 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
861 : :
862 : : uint32_t value;
863 [ - + ]: 1 : TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
864 : : RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD, &value),
865 : : 0, "Call to get port new event threshold failed");
866 [ - + ]: 1 : TEST_ASSERT_EQUAL((int32_t) value, pconf.new_event_threshold,
867 : : "Wrong port new event threshold");
868 : :
869 : : return TEST_SUCCESS;
870 : : }
871 : :
872 : : static int
873 : 1 : test_eventdev_port_count(void)
874 : : {
875 : : int ret;
876 : : struct rte_event_dev_info info;
877 : :
878 : 1 : ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
879 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
880 : :
881 : : uint32_t port_count;
882 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
883 : : RTE_EVENT_DEV_ATTR_PORT_COUNT,
884 : : &port_count), "Port count get failed");
885 [ - + ]: 1 : TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
886 : :
887 : : return TEST_SUCCESS;
888 : : }
889 : :
890 : : static int
891 : 1 : test_eventdev_timeout_ticks(void)
892 : : {
893 : : int ret;
894 : : uint64_t timeout_ticks;
895 : :
896 : 1 : ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
897 [ + - ]: 1 : if (ret != -ENOTSUP)
898 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
899 : :
900 : : return ret;
901 : : }
902 : :
903 : :
904 : : static int
905 : 1 : test_eventdev_start_stop(void)
906 : : {
907 : : int i, ret;
908 : :
909 : 1 : ret = eventdev_configure_setup();
910 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
911 : :
912 : : uint32_t queue_count;
913 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
914 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
915 : : "Queue count get failed");
916 [ + + ]: 65 : for (i = 0; i < (int)queue_count; i++) {
917 : 64 : ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
918 [ - + ]: 64 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
919 : : }
920 : :
921 : : uint32_t port_count;
922 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
923 : : RTE_EVENT_DEV_ATTR_PORT_COUNT,
924 : : &port_count), "Port count get failed");
925 : :
926 [ + + ]: 33 : for (i = 0; i < (int)port_count; i++) {
927 : 32 : ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
928 [ - + ]: 32 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
929 : : }
930 : :
931 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
932 [ - + ]: 1 : TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
933 : : TEST_DEV_ID);
934 : :
935 : 1 : ret = rte_event_dev_start(TEST_DEV_ID);
936 [ - + ]: 1 : TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
937 : :
938 : 1 : rte_event_dev_stop(TEST_DEV_ID);
939 : 1 : return TEST_SUCCESS;
940 : : }
941 : :
942 : :
943 : : static int
944 : 4 : eventdev_setup_device(void)
945 : : {
946 : : int i, ret;
947 : :
948 : 4 : ret = eventdev_configure_setup();
949 [ - + ]: 4 : TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
950 : :
951 : : uint32_t queue_count;
952 [ - + ]: 4 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
953 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
954 : : "Queue count get failed");
955 [ + + ]: 260 : for (i = 0; i < (int)queue_count; i++) {
956 : 256 : ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
957 [ - + ]: 256 : TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
958 : : }
959 : :
960 : : uint32_t port_count;
961 [ - + ]: 4 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
962 : : RTE_EVENT_DEV_ATTR_PORT_COUNT,
963 : : &port_count), "Port count get failed");
964 : :
965 [ + + ]: 132 : for (i = 0; i < (int)port_count; i++) {
966 : 128 : ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
967 [ - + ]: 128 : TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
968 : : }
969 : :
970 : 4 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
971 [ - + ]: 4 : TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
972 : : TEST_DEV_ID);
973 : :
974 : 4 : ret = rte_event_dev_start(TEST_DEV_ID);
975 [ - + ]: 4 : TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
976 : :
977 : : return TEST_SUCCESS;
978 : : }
979 : :
980 : : static void
981 : 5 : eventdev_stop_device(void)
982 : : {
983 : 5 : rte_event_dev_stop(TEST_DEV_ID);
984 : 5 : }
985 : :
986 : : static int
987 : 1 : test_eventdev_link(void)
988 : : {
989 : : int ret, nb_queues, i;
990 : : uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
991 : : uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
992 : :
993 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
994 [ - + ]: 1 : TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
995 : : TEST_DEV_ID);
996 : :
997 : : uint32_t queue_count;
998 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
999 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
1000 : : "Queue count get failed");
1001 : 1 : nb_queues = queue_count;
1002 [ + + ]: 65 : for (i = 0; i < nb_queues; i++) {
1003 : 64 : queues[i] = i;
1004 : 64 : priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
1005 : : }
1006 : :
1007 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
1008 : : priorities, nb_queues);
1009 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
1010 : : TEST_DEV_ID, ret);
1011 : : return TEST_SUCCESS;
1012 : : }
1013 : :
1014 : : static int
1015 : 1 : test_eventdev_unlink(void)
1016 : : {
1017 : : int ret, nb_queues, i;
1018 : : uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
1019 : :
1020 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
1021 [ - + ]: 1 : TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
1022 : : TEST_DEV_ID);
1023 : :
1024 : : uint32_t queue_count;
1025 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
1026 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
1027 : : "Queue count get failed");
1028 : 1 : nb_queues = queue_count;
1029 [ + + ]: 65 : for (i = 0; i < nb_queues; i++)
1030 : 64 : queues[i] = i;
1031 : :
1032 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
1033 [ - + ]: 1 : TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
1034 : : TEST_DEV_ID);
1035 : :
1036 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
1037 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
1038 : : TEST_DEV_ID, ret);
1039 : : return TEST_SUCCESS;
1040 : : }
1041 : :
1042 : : static int
1043 : 1 : test_eventdev_link_get(void)
1044 : : {
1045 : : int ret, i;
1046 : : uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
1047 : : uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
1048 : :
1049 : : /* link all queues */
1050 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
1051 [ - + ]: 1 : TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
1052 : : TEST_DEV_ID);
1053 : :
1054 : : uint32_t queue_count;
1055 [ - + ]: 1 : TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
1056 : : RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
1057 : : "Queue count get failed");
1058 : 1 : const int nb_queues = queue_count;
1059 [ + + ]: 65 : for (i = 0; i < nb_queues; i++)
1060 : 64 : queues[i] = i;
1061 : :
1062 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
1063 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
1064 : : TEST_DEV_ID, ret);
1065 : :
1066 : 1 : ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
1067 [ - + ]: 1 : TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
1068 : :
1069 : : /* link all queues and get the links */
1070 [ + + ]: 65 : for (i = 0; i < nb_queues; i++) {
1071 : 64 : queues[i] = i;
1072 : 64 : priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
1073 : : }
1074 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
1075 : : nb_queues);
1076 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
1077 : : TEST_DEV_ID, ret);
1078 : 1 : ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
1079 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
1080 : : TEST_DEV_ID, ret, nb_queues);
1081 : : /* unlink all*/
1082 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
1083 [ - + ]: 1 : TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
1084 : : TEST_DEV_ID, ret);
1085 : : /* link just one queue */
1086 : 1 : queues[0] = 0;
1087 : 1 : priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
1088 : :
1089 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
1090 [ - + ]: 1 : TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
1091 : : TEST_DEV_ID, ret);
1092 : 1 : ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
1093 [ - + ]: 1 : TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
1094 : : TEST_DEV_ID, ret, 1);
1095 : : /* unlink the queue */
1096 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
1097 [ - + ]: 1 : TEST_ASSERT(ret == 1, "Failed to unlink(device%d) ret=%d",
1098 : : TEST_DEV_ID, ret);
1099 : :
1100 : : /* 4links and 2 unlinks */
1101 [ + - ]: 1 : if (nb_queues >= 4) {
1102 [ + + ]: 5 : for (i = 0; i < 4; i++) {
1103 : 4 : queues[i] = i;
1104 : 4 : priorities[i] = 0x40;
1105 : : }
1106 : 1 : ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
1107 : : 4);
1108 [ - + ]: 1 : TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
1109 : : TEST_DEV_ID, ret);
1110 : :
1111 [ + + ]: 3 : for (i = 0; i < 2; i++)
1112 : 2 : queues[i] = i;
1113 : :
1114 : 1 : ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
1115 [ - + ]: 1 : TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
1116 : : TEST_DEV_ID, ret);
1117 : 1 : ret = rte_event_port_links_get(TEST_DEV_ID, 0,
1118 : : queues, priorities);
1119 [ - + ]: 1 : TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
1120 : : TEST_DEV_ID, ret, 2);
1121 [ - + ]: 1 : TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
1122 [ - + ]: 1 : TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
1123 : : ret, 0x40);
1124 [ - + ]: 1 : TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
1125 [ - + ]: 1 : TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
1126 : : ret, 0x40);
1127 : : }
1128 : :
1129 : : return TEST_SUCCESS;
1130 : : }
1131 : :
1132 : : static int
1133 : 1 : test_eventdev_profile_switch(void)
1134 : : {
1135 : : #define MAX_RETRIES 4
1136 : : uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
1137 : : uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
1138 : : struct rte_event_queue_conf qcfg;
1139 : : struct rte_event_port_conf pcfg;
1140 : : struct rte_event_dev_info info;
1141 : : struct rte_event ev;
1142 : : uint8_t q, re;
1143 : : int rc;
1144 : :
1145 : 1 : rte_event_dev_info_get(TEST_DEV_ID, &info);
1146 : :
1147 [ - + ]: 1 : if (info.max_profiles_per_port <= 1)
1148 : : return TEST_SKIPPED;
1149 : :
1150 [ # # ]: 0 : if (info.max_event_queues <= 1)
1151 : : return TEST_SKIPPED;
1152 : :
1153 : 0 : rc = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pcfg);
1154 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to get port0 default config");
1155 : 0 : rc = rte_event_port_setup(TEST_DEV_ID, 0, &pcfg);
1156 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to setup port0");
1157 : :
1158 : 0 : rc = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qcfg);
1159 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to get queue0 default config");
1160 : 0 : rc = rte_event_queue_setup(TEST_DEV_ID, 0, &qcfg);
1161 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to setup queue0");
1162 : :
1163 : 0 : q = 0;
1164 : 0 : rc = rte_event_port_profile_links_set(TEST_DEV_ID, 0, &q, NULL, 1, 0);
1165 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to link queue 0 to port 0 with profile 0");
1166 : 0 : q = 1;
1167 : 0 : rc = rte_event_port_profile_links_set(TEST_DEV_ID, 0, &q, NULL, 1, 1);
1168 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to link queue 1 to port 0 with profile 1");
1169 : :
1170 : 0 : rc = rte_event_port_profile_links_get(TEST_DEV_ID, 0, queues, priorities, 0);
1171 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to links");
1172 [ # # ]: 0 : TEST_ASSERT(queues[0] == 0, "Invalid queue found in link");
1173 : :
1174 : 0 : rc = rte_event_port_profile_links_get(TEST_DEV_ID, 0, queues, priorities, 1);
1175 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to links");
1176 [ # # ]: 0 : TEST_ASSERT(queues[0] == 1, "Invalid queue found in link");
1177 : :
1178 : 0 : rc = rte_event_dev_start(TEST_DEV_ID);
1179 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to start event device");
1180 : :
1181 : 0 : ev.event_type = RTE_EVENT_TYPE_CPU;
1182 : 0 : ev.queue_id = 0;
1183 : 0 : ev.op = RTE_EVENT_OP_NEW;
1184 : 0 : ev.flow_id = 0;
1185 : 0 : ev.u64 = 0xBADF00D0;
1186 : : rc = rte_event_enqueue_burst(TEST_DEV_ID, 0, &ev, 1);
1187 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to enqueue event");
1188 : 0 : ev.queue_id = 1;
1189 : 0 : ev.flow_id = 1;
1190 : : rc = rte_event_enqueue_burst(TEST_DEV_ID, 0, &ev, 1);
1191 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to enqueue event");
1192 : :
1193 : 0 : ev.event = 0;
1194 : 0 : ev.u64 = 0;
1195 : :
1196 : : rc = rte_event_port_profile_switch(TEST_DEV_ID, 0, 1);
1197 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to change profile");
1198 : :
1199 : : re = MAX_RETRIES;
1200 [ # # ]: 0 : while (re--) {
1201 : 0 : rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
1202 : : printf("rc %d\n", rc);
1203 [ # # ]: 0 : if (rc)
1204 : : break;
1205 : : }
1206 : :
1207 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to dequeue event from profile 1");
1208 [ # # ]: 0 : TEST_ASSERT(ev.flow_id == 1, "Incorrect flow identifier from profile 1");
1209 [ # # ]: 0 : TEST_ASSERT(ev.queue_id == 1, "Incorrect queue identifier from profile 1");
1210 : :
1211 : : re = MAX_RETRIES;
1212 [ # # ]: 0 : while (re--) {
1213 : : rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
1214 [ # # ]: 0 : TEST_ASSERT(rc == 0, "Unexpected event dequeued from active profile");
1215 : : }
1216 : :
1217 : : rc = rte_event_port_profile_switch(TEST_DEV_ID, 0, 0);
1218 [ # # ]: 0 : TEST_ASSERT_SUCCESS(rc, "Failed to change profile");
1219 : :
1220 : : re = MAX_RETRIES;
1221 [ # # ]: 0 : while (re--) {
1222 : 0 : rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
1223 [ # # ]: 0 : if (rc)
1224 : : break;
1225 : : }
1226 : :
1227 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to dequeue event from profile 1");
1228 [ # # ]: 0 : TEST_ASSERT(ev.flow_id == 0, "Incorrect flow identifier from profile 0");
1229 [ # # ]: 0 : TEST_ASSERT(ev.queue_id == 0, "Incorrect queue identifier from profile 0");
1230 : :
1231 : : re = MAX_RETRIES;
1232 [ # # ]: 0 : while (re--) {
1233 : : rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
1234 [ # # ]: 0 : TEST_ASSERT(rc == 0, "Unexpected event dequeued from active profile");
1235 : : }
1236 : :
1237 : 0 : q = 0;
1238 : 0 : rc = rte_event_port_profile_unlink(TEST_DEV_ID, 0, &q, 1, 0);
1239 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to unlink queue 0 to port 0 with profile 0");
1240 : 0 : q = 1;
1241 : 0 : rc = rte_event_port_profile_unlink(TEST_DEV_ID, 0, &q, 1, 1);
1242 [ # # ]: 0 : TEST_ASSERT(rc == 1, "Failed to unlink queue 1 to port 0 with profile 1");
1243 : :
1244 : : return TEST_SUCCESS;
1245 : : }
1246 : :
1247 : : static int
1248 : 1 : test_eventdev_close(void)
1249 : : {
1250 : 1 : rte_event_dev_stop(TEST_DEV_ID);
1251 : 1 : return rte_event_dev_close(TEST_DEV_ID);
1252 : : }
1253 : :
1254 : : static struct unit_test_suite eventdev_common_testsuite = {
1255 : : .suite_name = "eventdev common code unit test suite",
1256 : : .setup = testsuite_setup,
1257 : : .teardown = testsuite_teardown,
1258 : : .unit_test_cases = {
1259 : : TEST_CASE_ST(NULL, NULL,
1260 : : test_eventdev_count),
1261 : : TEST_CASE_ST(NULL, NULL,
1262 : : test_eventdev_get_dev_id),
1263 : : TEST_CASE_ST(NULL, NULL,
1264 : : test_eventdev_socket_id),
1265 : : TEST_CASE_ST(NULL, NULL,
1266 : : test_eventdev_info_get),
1267 : : TEST_CASE_ST(NULL, NULL,
1268 : : test_eventdev_configure),
1269 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1270 : : test_eventdev_queue_default_conf_get),
1271 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1272 : : test_eventdev_queue_setup),
1273 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1274 : : test_eventdev_queue_count),
1275 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1276 : : test_eventdev_queue_attr_priority),
1277 : : TEST_CASE_ST(eventdev_configure_setup, eventdev_stop_device,
1278 : : test_eventdev_queue_attr_priority_runtime),
1279 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1280 : : test_eventdev_queue_attr_weight_runtime),
1281 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1282 : : test_eventdev_queue_attr_affinity_runtime),
1283 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1284 : : test_eventdev_queue_attr_nb_atomic_flows),
1285 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1286 : : test_eventdev_queue_attr_nb_atomic_order_sequences),
1287 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1288 : : test_eventdev_queue_attr_event_queue_cfg),
1289 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1290 : : test_eventdev_port_default_conf_get),
1291 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1292 : : test_eventdev_port_setup),
1293 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1294 : : test_eventdev_port_attr_dequeue_depth),
1295 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1296 : : test_eventdev_port_attr_enqueue_depth),
1297 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1298 : : test_eventdev_port_attr_new_event_threshold),
1299 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1300 : : test_eventdev_port_count),
1301 : : TEST_CASE_ST(eventdev_configure_setup, NULL,
1302 : : test_eventdev_timeout_ticks),
1303 : : TEST_CASE_ST(NULL, NULL,
1304 : : test_eventdev_start_stop),
1305 : : TEST_CASE_ST(eventdev_configure_setup, eventdev_stop_device,
1306 : : test_eventdev_profile_switch),
1307 : : TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
1308 : : test_eventdev_link),
1309 : : TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
1310 : : test_eventdev_unlink),
1311 : : TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
1312 : : test_eventdev_link_get),
1313 : : TEST_CASE_ST(eventdev_setup_device, NULL,
1314 : : test_eventdev_close),
1315 : : TEST_CASES_END() /**< NULL terminate unit test array */
1316 : : }
1317 : : };
1318 : :
1319 : : static int
1320 : 1 : test_eventdev_common(void)
1321 : : {
1322 : 1 : return unit_test_suite_runner(&eventdev_common_testsuite);
1323 : : }
1324 : :
1325 : : static int
1326 : 1 : test_eventdev_selftest_impl(const char *pmd, const char *opts)
1327 : : {
1328 : : int ret = 0;
1329 : :
1330 [ + - ]: 1 : if (rte_event_dev_get_dev_id(pmd) == -ENODEV)
1331 : 1 : ret = rte_vdev_init(pmd, opts);
1332 [ + - ]: 1 : if (ret)
1333 : : return TEST_SKIPPED;
1334 : :
1335 : 1 : return rte_event_dev_selftest(rte_event_dev_get_dev_id(pmd));
1336 : : }
1337 : :
1338 : : static int
1339 : 1 : test_eventdev_selftest_sw(void)
1340 : : {
1341 : 1 : return test_eventdev_selftest_impl("event_sw", "");
1342 : : }
1343 : :
1344 : : static int
1345 : 0 : test_eventdev_selftest_octeontx(void)
1346 : : {
1347 : 0 : return test_eventdev_selftest_impl("event_octeontx", "");
1348 : : }
1349 : :
1350 : : static int
1351 : 0 : test_eventdev_selftest_dpaa2(void)
1352 : : {
1353 : 0 : return test_eventdev_selftest_impl("event_dpaa2", "");
1354 : : }
1355 : :
1356 : : static int
1357 : 0 : test_eventdev_selftest_dlb2(void)
1358 : : {
1359 : 0 : return test_eventdev_selftest_impl("dlb2_event", "");
1360 : : }
1361 : :
1362 : : static int
1363 : 0 : test_eventdev_selftest_cn9k(void)
1364 : : {
1365 : 0 : return test_eventdev_selftest_impl("event_cn9k", "");
1366 : : }
1367 : :
1368 : : static int
1369 : 0 : test_eventdev_selftest_cn10k(void)
1370 : : {
1371 : 0 : return test_eventdev_selftest_impl("event_cn10k", "");
1372 : : }
1373 : :
1374 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
1375 : :
1376 : 235 : REGISTER_FAST_TEST(eventdev_common_autotest, true, true, test_eventdev_common);
1377 : :
1378 : : #ifndef RTE_EXEC_ENV_WINDOWS
1379 : 235 : REGISTER_FAST_TEST(eventdev_selftest_sw, true, true, test_eventdev_selftest_sw);
1380 : 235 : REGISTER_DRIVER_TEST(eventdev_selftest_octeontx, test_eventdev_selftest_octeontx);
1381 : 235 : REGISTER_DRIVER_TEST(eventdev_selftest_dpaa2, test_eventdev_selftest_dpaa2);
1382 : 235 : REGISTER_DRIVER_TEST(eventdev_selftest_dlb2, test_eventdev_selftest_dlb2);
1383 : 235 : REGISTER_DRIVER_TEST(eventdev_selftest_cn9k, test_eventdev_selftest_cn9k);
1384 : 235 : REGISTER_DRIVER_TEST(eventdev_selftest_cn10k, test_eventdev_selftest_cn10k);
1385 : :
1386 : : #endif /* !RTE_EXEC_ENV_WINDOWS */
|