1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Cavium, Inc
3 * Copyright(c) 2017-2018 Intel Corporation.
6 #include <rte_atomic.h>
7 #include <rte_common.h>
8 #include <rte_cycles.h>
11 #include <rte_ethdev.h>
12 #include <rte_eventdev.h>
13 #include <rte_event_timer_adapter.h>
14 #include <rte_mempool.h>
15 #include <rte_launch.h>
16 #include <rte_lcore.h>
17 #include <rte_per_lcore.h>
18 #include <rte_random.h>
19 #include <rte_bus_vdev.h>
20 #include <rte_service.h>
25 /* 4K timers corresponds to sw evdev max inflight events */
26 #define MAX_TIMERS (4 * 1024)
29 #define NSECPERSEC 1E9
31 /* Both the app lcore and adapter ports are linked to this queue */
32 #define TEST_QUEUE_ID 0
33 /* Port the application dequeues from */
34 #define TEST_PORT_ID 0
35 #define TEST_ADAPTER_ID 0
37 /* Handle log statements in same manner as test macros */
38 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__)
41 static struct rte_event_timer_adapter *timdev;
42 static struct rte_mempool *eventdev_test_mempool;
43 static struct rte_ring *timer_producer_ring;
44 static uint64_t global_bkt_tck_ns;
45 static uint64_t global_info_bkt_tck_ns;
46 static volatile uint8_t arm_done;
48 #define CALC_TICKS(tks) \
49 ((tks * global_bkt_tck_ns) / global_info_bkt_tck_ns)
52 static bool using_services;
53 static uint32_t test_lcore1;
54 static uint32_t test_lcore2;
55 static uint32_t test_lcore3;
56 static uint32_t sw_evdev_slcore;
57 static uint32_t sw_adptr_slcore;
60 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
61 struct rte_event_dev_info *info)
63 memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
64 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
65 dev_conf->nb_event_ports = 1;
66 dev_conf->nb_event_queues = 1;
67 dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
68 dev_conf->nb_event_port_dequeue_depth =
69 info->max_event_port_dequeue_depth;
70 dev_conf->nb_event_port_enqueue_depth =
71 info->max_event_port_enqueue_depth;
72 dev_conf->nb_event_port_enqueue_depth =
73 info->max_event_port_enqueue_depth;
74 dev_conf->nb_events_limit =
82 struct rte_event_dev_config dev_conf;
83 struct rte_event_dev_info info;
86 ret = rte_event_dev_info_get(evdev, &info);
87 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
88 TEST_ASSERT(info.max_num_events < 0 ||
89 info.max_num_events >= (int32_t)MAX_TIMERS,
90 "ERROR max_num_events=%d < max_events=%d",
91 info.max_num_events, MAX_TIMERS);
93 devconf_set_default_sane_values(&dev_conf, &info);
94 ret = rte_event_dev_configure(evdev, &dev_conf);
95 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
97 ret = rte_event_queue_setup(evdev, 0, NULL);
98 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", 0);
100 /* Configure event port */
101 ret = rte_event_port_setup(evdev, 0, NULL);
102 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d", 0);
103 ret = rte_event_port_link(evdev, 0, NULL, NULL, 0);
104 TEST_ASSERT(ret >= 0, "Failed to link all queues port=%d", 0);
106 /* If this is a software event device, map and start its service */
107 if (rte_event_dev_service_id_get(evdev, &service_id) == 0) {
108 TEST_ASSERT_SUCCESS(rte_service_lcore_add(sw_evdev_slcore),
109 "Failed to add service core");
110 TEST_ASSERT_SUCCESS(rte_service_lcore_start(
112 "Failed to start service core");
113 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(
114 service_id, sw_evdev_slcore, 1),
115 "Failed to map evdev service");
116 TEST_ASSERT_SUCCESS(rte_service_runstate_set(
118 "Failed to start evdev service");
121 ret = rte_event_dev_start(evdev);
122 TEST_ASSERT_SUCCESS(ret, "Failed to start device");
128 testsuite_setup(void)
130 /* Some of the multithreaded tests require 3 other lcores to run */
131 unsigned int required_lcore_count = 4;
134 /* To make it easier to map services later if needed, just reset
135 * service core state.
137 (void) rte_service_lcore_reset_all();
139 if (!rte_event_dev_count()) {
140 /* If there is no hardware eventdev, or no software vdev was
141 * specified on the command line, create an instance of
144 LOG_DBG("Failed to find a valid event device... testing with"
145 " event_sw device\n");
146 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL),
147 "Error creating eventdev");
148 evdev = rte_event_dev_get_dev_id("event_sw0");
151 if (rte_event_dev_service_id_get(evdev, &service_id) == 0) {
152 /* A software event device will use a software event timer
153 * adapter as well. 2 more cores required to convert to
156 required_lcore_count += 2;
157 using_services = true;
160 if (rte_lcore_count() < required_lcore_count) {
161 printf("%d lcores needed to run tests", required_lcore_count);
165 /* Assign lcores for various tasks */
166 test_lcore1 = rte_get_next_lcore(-1, 1, 0);
167 test_lcore2 = rte_get_next_lcore(test_lcore1, 1, 0);
168 test_lcore3 = rte_get_next_lcore(test_lcore2, 1, 0);
169 if (using_services) {
170 sw_evdev_slcore = rte_get_next_lcore(test_lcore3, 1, 0);
171 sw_adptr_slcore = rte_get_next_lcore(sw_evdev_slcore, 1, 0);
174 return eventdev_setup();
178 testsuite_teardown(void)
180 rte_event_dev_stop(evdev);
181 rte_event_dev_close(evdev);
185 setup_adapter_service(struct rte_event_timer_adapter *adptr)
187 uint32_t adapter_service_id;
190 /* retrieve service ids */
191 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_service_id_get(adptr,
192 &adapter_service_id), "Failed to get event timer "
193 "adapter service id");
194 /* add a service core and start it */
195 ret = rte_service_lcore_add(sw_adptr_slcore);
196 TEST_ASSERT(ret == 0 || ret == -EALREADY,
197 "Failed to add service core");
198 ret = rte_service_lcore_start(sw_adptr_slcore);
199 TEST_ASSERT(ret == 0 || ret == -EALREADY,
200 "Failed to start service core");
202 /* map services to it */
203 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(adapter_service_id,
205 "Failed to map adapter service");
207 /* set services to running */
208 TEST_ASSERT_SUCCESS(rte_service_runstate_set(adapter_service_id, 1),
209 "Failed to start event timer adapter service");
215 test_port_conf_cb(uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id,
218 struct rte_event_dev_config dev_conf;
219 struct rte_event_dev_info info;
220 struct rte_event_port_conf *port_conf, def_port_conf = {0};
222 static int port_allocated;
223 static uint8_t port_id;
226 if (port_allocated) {
227 *event_port_id = port_id;
233 ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED,
239 rte_event_dev_stop(event_dev_id);
241 ret = rte_event_dev_info_get(evdev, &info);
245 devconf_set_default_sane_values(&dev_conf, &info);
247 port_id = dev_conf.nb_event_ports;
248 dev_conf.nb_event_ports++;
250 ret = rte_event_dev_configure(event_dev_id, &dev_conf);
253 rte_event_dev_start(event_dev_id);
257 if (conf_arg != NULL)
258 port_conf = conf_arg;
260 port_conf = &def_port_conf;
261 ret = rte_event_port_default_conf_get(event_dev_id, port_id,
267 ret = rte_event_port_setup(event_dev_id, port_id, port_conf);
271 *event_port_id = port_id;
274 rte_event_dev_start(event_dev_id);
276 /* Reuse this port number next time this is called */
283 _timdev_setup(uint64_t max_tmo_ns, uint64_t bkt_tck_ns)
285 struct rte_event_timer_adapter_info info;
286 struct rte_event_timer_adapter_conf config = {
287 .event_dev_id = evdev,
288 .timer_adapter_id = TEST_ADAPTER_ID,
289 .timer_tick_ns = bkt_tck_ns,
290 .max_tmo_ns = max_tmo_ns,
291 .nb_timers = MAX_TIMERS * 10,
292 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
295 const char *pool_name = "timdev_test_pool";
297 global_bkt_tck_ns = bkt_tck_ns;
299 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps),
300 "failed to get adapter capabilities");
301 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) {
302 timdev = rte_event_timer_adapter_create_ext(&config,
305 setup_adapter_service(timdev);
306 using_services = true;
308 timdev = rte_event_timer_adapter_create(&config);
310 TEST_ASSERT_NOT_NULL(timdev,
311 "failed to create event timer ring");
313 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), 0,
314 "failed to Start event timer adapter");
316 /* Create event timer mempool */
317 eventdev_test_mempool = rte_mempool_create(pool_name,
319 sizeof(struct rte_event_timer), /* element size*/
321 0, NULL, NULL, NULL, NULL,
323 if (!eventdev_test_mempool) {
324 printf("ERROR creating mempool\n");
328 rte_event_timer_adapter_get_info(timdev, &info);
330 global_info_bkt_tck_ns = info.min_resolution_ns;
336 timdev_setup_usec(void)
338 return using_services ?
339 /* Max timeout is 10,000us and bucket interval is 100us */
340 _timdev_setup(1E7, 1E5) :
341 /* Max timeout is 100us and bucket interval is 1us */
342 _timdev_setup(1E5, 1E3);
346 timdev_setup_usec_multicore(void)
348 return using_services ?
349 /* Max timeout is 10,000us and bucket interval is 100us */
350 _timdev_setup(1E7, 1E5) :
351 /* Max timeout is 100us and bucket interval is 1us */
352 _timdev_setup(1E5, 1E3);
356 timdev_setup_msec(void)
358 /* Max timeout is 2 mins, and bucket interval is 100 ms */
359 return _timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10);
363 timdev_setup_sec(void)
365 /* Max timeout is 100sec and bucket interval is 1sec */
366 return _timdev_setup(1E11, 1E9);
370 timdev_setup_sec_multicore(void)
372 /* Max timeout is 100sec and bucket interval is 1sec */
373 return _timdev_setup(1E11, 1E9);
377 timdev_teardown(void)
379 rte_event_timer_adapter_stop(timdev);
380 rte_event_timer_adapter_free(timdev);
382 rte_mempool_free(eventdev_test_mempool);
386 test_timer_state(void)
388 struct rte_event_timer *ev_tim;
390 const struct rte_event_timer tim = {
391 .ev.op = RTE_EVENT_OP_NEW,
393 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
394 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
395 .ev.event_type = RTE_EVENT_TYPE_TIMER,
396 .state = RTE_EVENT_TIMER_NOT_ARMED,
400 rte_mempool_get(eventdev_test_mempool, (void **)&ev_tim);
402 ev_tim->ev.event_ptr = ev_tim;
403 ev_tim->timeout_ticks = CALC_TICKS(120);
405 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 0,
406 "Armed timer exceeding max_timeout.");
407 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ERROR_TOOLATE,
408 "Improper timer state set expected %d returned %d",
409 RTE_EVENT_TIMER_ERROR_TOOLATE, ev_tim->state);
411 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED;
412 ev_tim->timeout_ticks = CALC_TICKS(10);
414 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1,
415 "Failed to arm timer with proper timeout.");
416 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED,
417 "Improper timer state set expected %d returned %d",
418 RTE_EVENT_TIMER_ARMED, ev_tim->state);
423 rte_delay_us(1000 + 200);
424 TEST_ASSERT_EQUAL(rte_event_dequeue_burst(evdev, 0, &ev, 1, 0), 1,
425 "Armed timer failed to trigger.");
427 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED;
428 ev_tim->timeout_ticks = CALC_TICKS(90);
429 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1,
430 "Failed to arm timer with proper timeout.");
431 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, &ev_tim, 1),
432 1, "Failed to cancel armed timer");
433 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_CANCELED,
434 "Improper timer state set expected %d returned %d",
435 RTE_EVENT_TIMER_CANCELED, ev_tim->state);
437 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim);
443 _arm_timers(uint64_t timeout_tcks, uint64_t timers)
446 struct rte_event_timer *ev_tim;
447 const struct rte_event_timer tim = {
448 .ev.op = RTE_EVENT_OP_NEW,
450 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
451 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
452 .ev.event_type = RTE_EVENT_TYPE_TIMER,
453 .state = RTE_EVENT_TIMER_NOT_ARMED,
454 .timeout_ticks = CALC_TICKS(timeout_tcks),
457 for (i = 0; i < timers; i++) {
459 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
461 "mempool alloc failed");
463 ev_tim->ev.event_ptr = ev_tim;
465 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
466 1), 1, "Failed to arm timer %d",
474 _wait_timer_triggers(uint64_t wait_sec, uint64_t arm_count,
475 uint64_t cancel_count)
479 uint64_t wait_start, max_wait;
482 max_wait = rte_get_timer_hz() * wait_sec;
483 wait_start = rte_get_timer_cycles();
485 if (rte_get_timer_cycles() - wait_start > max_wait) {
486 if (events + cancel_count != arm_count)
487 TEST_ASSERT_SUCCESS(max_wait,
488 "Max time limit for timers exceeded.");
492 valid_event = rte_event_dequeue_burst(evdev, 0, &ev, 1, 0);
496 rte_mempool_put(eventdev_test_mempool, ev.event_ptr);
506 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS),
507 "Failed to arm timers");
508 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0),
509 "Timer triggered count doesn't match arm count");
514 _arm_wrapper(void *arg)
518 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS),
519 "Failed to arm timers");
525 test_timer_arm_multicore(void)
528 uint32_t lcore_1 = rte_get_next_lcore(-1, 1, 0);
529 uint32_t lcore_2 = rte_get_next_lcore(lcore_1, 1, 0);
531 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_1);
532 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_2);
534 rte_eal_mp_wait_lcore();
535 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0),
536 "Timer triggered count doesn't match arm count");
543 _arm_timers_burst(uint64_t timeout_tcks, uint64_t timers)
547 struct rte_event_timer *ev_tim[MAX_BURST];
548 const struct rte_event_timer tim = {
549 .ev.op = RTE_EVENT_OP_NEW,
551 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
552 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
553 .ev.event_type = RTE_EVENT_TYPE_TIMER,
554 .state = RTE_EVENT_TIMER_NOT_ARMED,
555 .timeout_ticks = CALC_TICKS(timeout_tcks),
558 for (i = 0; i < timers / MAX_BURST; i++) {
559 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk(
560 eventdev_test_mempool,
561 (void **)ev_tim, MAX_BURST),
562 "mempool alloc failed");
564 for (j = 0; j < MAX_BURST; j++) {
566 ev_tim[j]->ev.event_ptr = ev_tim[j];
569 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev,
570 ev_tim, tim.timeout_ticks, MAX_BURST),
571 MAX_BURST, "Failed to arm timer %d", rte_errno);
578 test_timer_arm_burst(void)
580 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS),
581 "Failed to arm timers");
582 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0),
583 "Timer triggered count doesn't match arm count");
589 _arm_wrapper_burst(void *arg)
593 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS),
594 "Failed to arm timers");
600 test_timer_arm_burst_multicore(void)
602 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore1);
603 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore2);
605 rte_eal_mp_wait_lcore();
606 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0),
607 "Timer triggered count doesn't match arm count");
613 test_timer_cancel(void)
616 struct rte_event_timer *ev_tim;
617 const struct rte_event_timer tim = {
618 .ev.op = RTE_EVENT_OP_NEW,
620 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
621 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
622 .ev.event_type = RTE_EVENT_TYPE_TIMER,
623 .state = RTE_EVENT_TIMER_NOT_ARMED,
624 .timeout_ticks = CALC_TICKS(20),
627 for (i = 0; i < MAX_TIMERS; i++) {
628 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
630 "mempool alloc failed");
632 ev_tim->ev.event_ptr = ev_tim;
634 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
635 1), 1, "Failed to arm timer %d",
638 rte_delay_us(100 + (i % 5000));
640 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev,
642 "Failed to cancel event timer %d", rte_errno);
643 rte_mempool_put(eventdev_test_mempool, ev_tim);
647 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
649 "Timer triggered count doesn't match arm, cancel count");
655 _cancel_producer(uint64_t timeout_tcks, uint64_t timers)
658 struct rte_event_timer *ev_tim;
659 const struct rte_event_timer tim = {
660 .ev.op = RTE_EVENT_OP_NEW,
662 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
663 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
664 .ev.event_type = RTE_EVENT_TYPE_TIMER,
665 .state = RTE_EVENT_TIMER_NOT_ARMED,
666 .timeout_ticks = CALC_TICKS(timeout_tcks),
669 for (i = 0; i < timers; i++) {
670 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
672 "mempool alloc failed");
675 ev_tim->ev.event_ptr = ev_tim;
677 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
678 1), 1, "Failed to arm timer %d",
681 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED,
682 "Failed to arm event timer");
684 while (rte_ring_enqueue(timer_producer_ring, ev_tim) != 0)
692 _cancel_producer_burst(uint64_t timeout_tcks, uint64_t timers)
697 struct rte_event_timer *ev_tim[MAX_BURST];
698 const struct rte_event_timer tim = {
699 .ev.op = RTE_EVENT_OP_NEW,
701 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
702 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
703 .ev.event_type = RTE_EVENT_TYPE_TIMER,
704 .state = RTE_EVENT_TIMER_NOT_ARMED,
705 .timeout_ticks = CALC_TICKS(timeout_tcks),
709 for (i = 0; i < timers / MAX_BURST; i++) {
710 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk(
711 eventdev_test_mempool,
712 (void **)ev_tim, MAX_BURST),
713 "mempool alloc failed");
715 for (j = 0; j < MAX_BURST; j++) {
717 ev_tim[j]->ev.event_ptr = ev_tim[j];
720 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev,
721 ev_tim, tim.timeout_ticks, MAX_BURST),
722 MAX_BURST, "Failed to arm timer %d", rte_errno);
724 for (j = 0; j < MAX_BURST; j++)
725 TEST_ASSERT_EQUAL(ev_tim[j]->state,
726 RTE_EVENT_TIMER_ARMED,
727 "Event timer not armed, state = %d",
730 ret = rte_ring_enqueue_bulk(timer_producer_ring,
731 (void **)ev_tim, MAX_BURST, NULL);
732 TEST_ASSERT_EQUAL(ret, MAX_BURST,
733 "Failed to enqueue event timers to ring");
737 TEST_ASSERT_EQUAL(arm_count, MAX_TIMERS,
738 "Failed to arm expected number of event timers");
744 _cancel_producer_wrapper(void *args)
748 return _cancel_producer(20, MAX_TIMERS);
752 _cancel_producer_burst_wrapper(void *args)
756 return _cancel_producer_burst(100, MAX_TIMERS);
760 _cancel_thread(void *args)
763 struct rte_event_timer *ev_tim = NULL;
764 uint64_t cancel_count = 0;
767 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) {
768 if (rte_ring_dequeue(timer_producer_ring, (void **)&ev_tim))
771 ret = rte_event_timer_cancel_burst(timdev, &ev_tim, 1);
772 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel timer");
773 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim);
781 _cancel_burst_thread(void *args)
786 struct rte_event_timer *ev_tim[MAX_BURST];
787 uint64_t cancel_count = 0;
788 uint64_t dequeue_count = 0;
790 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) {
791 n = rte_ring_dequeue_burst(timer_producer_ring,
792 (void **)ev_tim, MAX_BURST, NULL);
798 for (i = 0; i < n; i++)
799 TEST_ASSERT_EQUAL(ev_tim[i]->state,
800 RTE_EVENT_TIMER_ARMED,
801 "Event timer not armed, state = %d",
804 ret = rte_event_timer_cancel_burst(timdev, ev_tim, n);
805 TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of "
807 rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim,
808 RTE_MIN(ret, MAX_BURST));
813 TEST_ASSERT_EQUAL(cancel_count, MAX_TIMERS,
814 "Failed to cancel expected number of timers: "
815 "expected = %d, cancel_count = %"PRIu64", "
816 "dequeue_count = %"PRIu64"\n", MAX_TIMERS,
817 cancel_count, dequeue_count);
823 test_timer_cancel_multicore(void)
826 timer_producer_ring = rte_ring_create("timer_cancel_queue",
827 MAX_TIMERS * 2, rte_socket_id(), 0);
828 TEST_ASSERT_NOT_NULL(timer_producer_ring,
829 "Unable to reserve memory for ring");
831 rte_eal_remote_launch(_cancel_thread, NULL, test_lcore3);
832 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore1);
833 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore2);
835 rte_eal_wait_lcore(test_lcore1);
836 rte_eal_wait_lcore(test_lcore2);
838 rte_eal_wait_lcore(test_lcore3);
839 rte_ring_free(timer_producer_ring);
841 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS * 2,
843 "Timer triggered count doesn't match arm count");
849 test_timer_cancel_burst_multicore(void)
852 timer_producer_ring = rte_ring_create("timer_cancel_queue",
853 MAX_TIMERS * 2, rte_socket_id(), 0);
854 TEST_ASSERT_NOT_NULL(timer_producer_ring,
855 "Unable to reserve memory for ring");
857 rte_eal_remote_launch(_cancel_burst_thread, NULL, test_lcore2);
858 rte_eal_remote_launch(_cancel_producer_burst_wrapper, NULL,
861 rte_eal_wait_lcore(test_lcore1);
863 rte_eal_wait_lcore(test_lcore2);
864 rte_ring_free(timer_producer_ring);
866 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
868 "Timer triggered count doesn't match arm count");
874 test_timer_cancel_random(void)
877 uint64_t events_canceled = 0;
878 struct rte_event_timer *ev_tim;
879 const struct rte_event_timer tim = {
880 .ev.op = RTE_EVENT_OP_NEW,
882 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
883 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
884 .ev.event_type = RTE_EVENT_TYPE_TIMER,
885 .state = RTE_EVENT_TIMER_NOT_ARMED,
886 .timeout_ticks = CALC_TICKS(20),
889 for (i = 0; i < MAX_TIMERS; i++) {
891 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
893 "mempool alloc failed");
895 ev_tim->ev.event_ptr = ev_tim;
897 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
898 1), 1, "Failed to arm timer %d",
901 if (rte_rand() & 1) {
902 rte_delay_us(100 + (i % 5000));
903 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(
906 "Failed to cancel event timer %d", rte_errno);
907 rte_mempool_put(eventdev_test_mempool, ev_tim);
912 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
914 "Timer triggered count doesn't match arm, cancel count");
919 /* Check that the adapter can be created correctly */
924 struct rte_event_timer_adapter *adapter, *adapter2;
926 struct rte_event_timer_adapter_conf conf = {
927 .event_dev_id = evdev + 1, // invalid event dev id
928 .timer_adapter_id = adapter_id,
929 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
930 .timer_tick_ns = NSECPERSEC / 10,
931 .max_tmo_ns = 180 * NSECPERSEC,
932 .nb_timers = MAX_TIMERS,
933 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
937 /* Test invalid conf */
938 adapter = rte_event_timer_adapter_create(&conf);
939 TEST_ASSERT_NULL(adapter, "Created adapter with invalid "
941 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Incorrect errno value for "
942 "invalid event device id");
944 /* Test valid conf */
945 conf.event_dev_id = evdev;
946 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps),
947 "failed to get adapter capabilities");
948 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT))
949 adapter = rte_event_timer_adapter_create_ext(&conf,
953 adapter = rte_event_timer_adapter_create(&conf);
954 TEST_ASSERT_NOT_NULL(adapter, "Failed to create adapter with valid "
957 /* Test existing id */
958 adapter2 = rte_event_timer_adapter_create(&conf);
959 TEST_ASSERT_NULL(adapter2, "Created adapter with in-use id");
960 TEST_ASSERT(rte_errno == EEXIST, "Incorrect errno value for existing "
963 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapter),
964 "Failed to free adapter");
966 rte_mempool_free(eventdev_test_mempool);
972 /* Test that adapter can be freed correctly. */
976 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev),
977 "Failed to stop adapter");
979 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev),
980 "Failed to free valid adapter");
982 /* Test free of already freed adapter */
983 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev),
984 "Freed adapter that was already freed");
986 /* Test free of null adapter */
988 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev),
989 "Freed null adapter");
991 rte_mempool_free(eventdev_test_mempool);
996 /* Test that adapter info can be retrieved and is correct. */
998 adapter_get_info(void)
1000 struct rte_event_timer_adapter_info info;
1002 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_get_info(timdev, &info),
1003 "Failed to get adapter info");
1006 TEST_ASSERT_EQUAL(info.event_dev_port_id, 1,
1007 "Expected port id = 1, got port id = %d",
1008 info.event_dev_port_id);
1010 return TEST_SUCCESS;
1013 /* Test adapter lookup via adapter ID. */
1015 adapter_lookup(void)
1017 struct rte_event_timer_adapter *adapter;
1019 adapter = rte_event_timer_adapter_lookup(TEST_ADAPTER_ID);
1020 TEST_ASSERT_NOT_NULL(adapter, "Failed to lookup adapter");
1022 return TEST_SUCCESS;
1028 TEST_ASSERT_SUCCESS(_timdev_setup(180 * NSECPERSEC,
1030 "Failed to start adapter");
1031 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), -EALREADY,
1032 "Timer adapter started without call to stop.");
1034 return TEST_SUCCESS;
1037 /* Test that adapter stops correctly. */
1041 struct rte_event_timer_adapter *l_adapter = NULL;
1043 /* Test adapter stop */
1044 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev),
1045 "Failed to stop event adapter");
1047 TEST_ASSERT_FAIL(rte_event_timer_adapter_stop(l_adapter),
1048 "Erroneously stopped null event adapter");
1050 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev),
1051 "Failed to free adapter");
1053 rte_mempool_free(eventdev_test_mempool);
1055 return TEST_SUCCESS;
1058 /* Test increment and reset of ev_enq_count stat */
1060 stat_inc_reset_ev_enq(void)
1063 int num_evtims = MAX_TIMERS;
1064 struct rte_event_timer *evtims[num_evtims];
1065 struct rte_event evs[BATCH_SIZE];
1066 struct rte_event_timer_adapter_stats stats;
1067 const struct rte_event_timer init_tim = {
1068 .ev.op = RTE_EVENT_OP_NEW,
1069 .ev.queue_id = TEST_QUEUE_ID,
1070 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1071 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1072 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1073 .state = RTE_EVENT_TIMER_NOT_ARMED,
1074 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1077 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims,
1079 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d",
1082 for (i = 0; i < num_evtims; i++) {
1083 *evtims[i] = init_tim;
1084 evtims[i]->ev.event_ptr = evtims[i];
1087 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1088 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1089 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, "Stats not clear at "
1092 /* Test with the max value for the adapter */
1093 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims);
1094 TEST_ASSERT_EQUAL(ret, num_evtims,
1095 "Failed to arm all event timers: attempted = %d, "
1096 "succeeded = %d, rte_errno = %s",
1097 num_evtims, ret, rte_strerror(rte_errno));
1101 #define MAX_TRIES num_evtims
1106 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs,
1108 if (sum >= num_evtims || ++tries >= MAX_TRIES)
1114 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, "
1115 "got %d", num_evtims, sum);
1117 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries");
1121 /* Make sure the eventdev is still empty */
1122 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs),
1125 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry "
1126 "events from event device");
1128 /* Check stats again */
1129 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1130 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1131 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, num_evtims,
1132 "Expected enqueue stat = %d; got %d", num_evtims,
1133 (int)stats.ev_enq_count);
1135 /* Reset and check again */
1136 ret = rte_event_timer_adapter_stats_reset(timdev);
1137 TEST_ASSERT_EQUAL(ret, 0, "Failed to reset stats");
1139 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1140 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1141 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0,
1142 "Expected enqueue stat = %d; got %d", 0,
1143 (int)stats.ev_enq_count);
1145 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims,
1148 return TEST_SUCCESS;
1151 /* Test various cases in arming timers */
1153 event_timer_arm(void)
1157 struct rte_event_timer_adapter *adapter = timdev;
1158 struct rte_event_timer *evtim = NULL;
1159 struct rte_event evs[BATCH_SIZE];
1160 const struct rte_event_timer init_tim = {
1161 .ev.op = RTE_EVENT_OP_NEW,
1162 .ev.queue_id = TEST_QUEUE_ID,
1163 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1164 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1165 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1166 .state = RTE_EVENT_TIMER_NOT_ARMED,
1167 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1170 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1171 if (evtim == NULL) {
1172 /* Failed to get an event timer object */
1176 /* Set up a timer */
1178 evtim->ev.event_ptr = evtim;
1180 /* Test single timer arm succeeds */
1181 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1182 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1183 rte_strerror(rte_errno));
1184 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event timer "
1185 "in incorrect state");
1187 /* Test arm of armed timer fails */
1188 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1189 TEST_ASSERT_EQUAL(ret, 0, "expected return value from "
1190 "rte_event_timer_arm_burst: 0, got: %d", ret);
1191 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1192 "after arming already armed timer");
1194 /* Let timer expire */
1197 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1198 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1199 "events from event device");
1201 rte_mempool_put(eventdev_test_mempool, evtim);
1203 return TEST_SUCCESS;
1206 /* This test checks that repeated references to the same event timer in the
1207 * arm request work as expected; only the first one through should succeed.
1210 event_timer_arm_double(void)
1214 struct rte_event_timer_adapter *adapter = timdev;
1215 struct rte_event_timer *evtim = NULL;
1216 struct rte_event evs[BATCH_SIZE];
1217 const struct rte_event_timer init_tim = {
1218 .ev.op = RTE_EVENT_OP_NEW,
1219 .ev.queue_id = TEST_QUEUE_ID,
1220 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1221 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1222 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1223 .state = RTE_EVENT_TIMER_NOT_ARMED,
1224 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1227 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1228 if (evtim == NULL) {
1229 /* Failed to get an event timer object */
1233 /* Set up a timer */
1235 evtim->ev.event_ptr = evtim;
1237 struct rte_event_timer *evtim_arr[] = {evtim, evtim};
1238 ret = rte_event_timer_arm_burst(adapter, evtim_arr, RTE_DIM(evtim_arr));
1239 TEST_ASSERT_EQUAL(ret, 1, "Unexpected return value from "
1240 "rte_event_timer_arm_burst");
1241 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1242 "after double-arm");
1244 /* Let timer expire */
1247 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1248 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number of expiry events - "
1249 "expected: 1, actual: %d", n);
1251 rte_mempool_put(eventdev_test_mempool, evtim);
1253 return TEST_SUCCESS;
1256 /* Test the timer expiry event is generated at the expected time. */
1258 event_timer_arm_expiry(void)
1262 struct rte_event_timer_adapter *adapter = timdev;
1263 struct rte_event_timer *evtim = NULL;
1264 struct rte_event_timer *evtim2 = NULL;
1265 struct rte_event evs[BATCH_SIZE];
1266 const struct rte_event_timer init_tim = {
1267 .ev.op = RTE_EVENT_OP_NEW,
1268 .ev.queue_id = TEST_QUEUE_ID,
1269 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1270 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1271 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1272 .state = RTE_EVENT_TIMER_NOT_ARMED,
1275 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1276 if (evtim == NULL) {
1277 /* Failed to get an event timer object */
1281 /* Set up an event timer */
1283 evtim->timeout_ticks = CALC_TICKS(30), // expire in 3 secs
1284 evtim->ev.event_ptr = evtim;
1286 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1287 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s",
1288 rte_strerror(rte_errno));
1289 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event "
1290 "timer in incorrect state");
1294 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1295 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event");
1297 /* Delay 100 ms to account for the adapter tick window - should let us
1302 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1303 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number (%d) of timer "
1304 "expiry events", n);
1305 TEST_ASSERT_EQUAL(evs[0].event_type, RTE_EVENT_TYPE_TIMER,
1306 "Dequeued unexpected type of event");
1308 /* Check that we recover the original event timer and then free it */
1309 evtim2 = evs[0].event_ptr;
1310 TEST_ASSERT_EQUAL(evtim, evtim2,
1311 "Failed to recover pointer to original event timer");
1312 rte_mempool_put(eventdev_test_mempool, evtim2);
1314 return TEST_SUCCESS;
1317 /* Check that rearming a timer works as expected. */
1319 event_timer_arm_rearm(void)
1323 struct rte_event_timer *evtim = NULL;
1324 struct rte_event_timer *evtim2 = NULL;
1325 struct rte_event evs[BATCH_SIZE];
1326 const struct rte_event_timer init_tim = {
1327 .ev.op = RTE_EVENT_OP_NEW,
1328 .ev.queue_id = TEST_QUEUE_ID,
1329 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1330 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1331 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1332 .state = RTE_EVENT_TIMER_NOT_ARMED,
1335 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1336 if (evtim == NULL) {
1337 /* Failed to get an event timer object */
1341 /* Set up a timer */
1343 evtim->timeout_ticks = CALC_TICKS(1); // expire in 0.1 sec
1344 evtim->ev.event_ptr = evtim;
1347 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1348 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1349 rte_strerror(rte_errno));
1351 /* Add 100ms to account for the adapter tick window */
1352 rte_delay_ms(100 + 100);
1354 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1355 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1356 "events from event device");
1358 /* Recover the timer through the event that was dequeued. */
1359 evtim2 = evs[0].event_ptr;
1360 TEST_ASSERT_EQUAL(evtim, evtim2,
1361 "Failed to recover pointer to original event timer");
1363 /* Need to reset state in case implementation can't do it */
1364 evtim2->state = RTE_EVENT_TIMER_NOT_ARMED;
1367 ret = rte_event_timer_arm_burst(timdev, &evtim2, 1);
1368 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1369 rte_strerror(rte_errno));
1371 /* Add 100ms to account for the adapter tick window */
1372 rte_delay_ms(100 + 100);
1374 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1375 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1376 "events from event device");
1379 evtim2 = evs[0].event_ptr;
1380 TEST_ASSERT_EQUAL(evtim, evtim2,
1381 "Failed to recover pointer to original event timer");
1382 rte_mempool_put(eventdev_test_mempool, evtim2);
1384 return TEST_SUCCESS;
1387 /* Check that the adapter handles the max specified number of timers as
1391 event_timer_arm_max(void)
1394 int num_evtims = MAX_TIMERS;
1395 struct rte_event_timer *evtims[num_evtims];
1396 struct rte_event evs[BATCH_SIZE];
1397 const struct rte_event_timer init_tim = {
1398 .ev.op = RTE_EVENT_OP_NEW,
1399 .ev.queue_id = TEST_QUEUE_ID,
1400 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1401 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1402 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1403 .state = RTE_EVENT_TIMER_NOT_ARMED,
1404 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1407 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims,
1409 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d",
1412 for (i = 0; i < num_evtims; i++) {
1413 *evtims[i] = init_tim;
1414 evtims[i]->ev.event_ptr = evtims[i];
1417 /* Test with the max value for the adapter */
1418 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims);
1419 TEST_ASSERT_EQUAL(ret, num_evtims,
1420 "Failed to arm all event timers: attempted = %d, "
1421 "succeeded = %d, rte_errno = %s",
1422 num_evtims, ret, rte_strerror(rte_errno));
1426 #define MAX_TRIES num_evtims
1431 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs,
1433 if (sum >= num_evtims || ++tries >= MAX_TRIES)
1439 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, "
1440 "got %d", num_evtims, sum);
1442 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries");
1446 /* Make sure the eventdev is still empty */
1447 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs),
1450 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry "
1451 "events from event device");
1453 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims,
1456 return TEST_SUCCESS;
1459 /* Check that creating an event timer with incorrect event sched type fails. */
1461 event_timer_arm_invalid_sched_type(void)
1464 struct rte_event_timer *evtim = NULL;
1465 const struct rte_event_timer init_tim = {
1466 .ev.op = RTE_EVENT_OP_NEW,
1467 .ev.queue_id = TEST_QUEUE_ID,
1468 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1469 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1470 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1471 .state = RTE_EVENT_TIMER_NOT_ARMED,
1472 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1475 if (!using_services)
1478 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1479 if (evtim == NULL) {
1480 /* Failed to get an event timer object */
1485 evtim->ev.event_ptr = evtim;
1486 evtim->ev.sched_type = RTE_SCHED_TYPE_PARALLEL; // bad sched type
1488 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1489 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1490 "sched type, but didn't");
1491 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1492 " arm fail with invalid queue");
1494 rte_mempool_put(eventdev_test_mempool, &evtim);
1496 return TEST_SUCCESS;
1499 /* Check that creating an event timer with a timeout value that is too small or
1503 event_timer_arm_invalid_timeout(void)
1506 struct rte_event_timer *evtim = NULL;
1507 const struct rte_event_timer init_tim = {
1508 .ev.op = RTE_EVENT_OP_NEW,
1509 .ev.queue_id = TEST_QUEUE_ID,
1510 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1511 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1512 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1513 .state = RTE_EVENT_TIMER_NOT_ARMED,
1514 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1517 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1518 if (evtim == NULL) {
1519 /* Failed to get an event timer object */
1524 evtim->ev.event_ptr = evtim;
1525 evtim->timeout_ticks = 0; // timeout too small
1527 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1528 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1529 "timeout, but didn't");
1530 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1531 " arm fail with invalid timeout");
1532 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOEARLY,
1533 "Unexpected event timer state");
1536 evtim->ev.event_ptr = evtim;
1537 evtim->timeout_ticks = CALC_TICKS(1801); // timeout too big
1539 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1540 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1541 "timeout, but didn't");
1542 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1543 " arm fail with invalid timeout");
1544 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOLATE,
1545 "Unexpected event timer state");
1547 rte_mempool_put(eventdev_test_mempool, evtim);
1549 return TEST_SUCCESS;
1553 event_timer_cancel(void)
1557 struct rte_event_timer_adapter *adapter = timdev;
1558 struct rte_event_timer *evtim = NULL;
1559 struct rte_event evs[BATCH_SIZE];
1560 const struct rte_event_timer init_tim = {
1561 .ev.op = RTE_EVENT_OP_NEW,
1562 .ev.queue_id = TEST_QUEUE_ID,
1563 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1564 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1565 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1566 .state = RTE_EVENT_TIMER_NOT_ARMED,
1569 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1570 if (evtim == NULL) {
1571 /* Failed to get an event timer object */
1575 /* Check that cancelling an uninited timer fails */
1576 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1577 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling "
1579 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after "
1580 "cancelling uninited timer");
1582 /* Set up a timer */
1584 evtim->ev.event_ptr = evtim;
1585 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec
1587 /* Check that cancelling an inited but unarmed timer fails */
1588 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1589 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling "
1591 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after "
1592 "cancelling unarmed timer");
1594 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1595 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1596 rte_strerror(rte_errno));
1597 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED,
1598 "evtim in incorrect state");
1603 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1604 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel event_timer: %s\n",
1605 rte_strerror(rte_errno));
1606 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_CANCELED,
1607 "evtim in incorrect state");
1611 /* Make sure that no expiry event was generated */
1612 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1613 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n");
1615 rte_mempool_put(eventdev_test_mempool, evtim);
1617 return TEST_SUCCESS;
1621 event_timer_cancel_double(void)
1625 struct rte_event_timer_adapter *adapter = timdev;
1626 struct rte_event_timer *evtim = NULL;
1627 struct rte_event evs[BATCH_SIZE];
1628 const struct rte_event_timer init_tim = {
1629 .ev.op = RTE_EVENT_OP_NEW,
1630 .ev.queue_id = TEST_QUEUE_ID,
1631 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1632 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1633 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1634 .state = RTE_EVENT_TIMER_NOT_ARMED,
1635 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1638 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1639 if (evtim == NULL) {
1640 /* Failed to get an event timer object */
1644 /* Set up a timer */
1646 evtim->ev.event_ptr = evtim;
1647 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec
1649 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1650 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1651 rte_strerror(rte_errno));
1652 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED,
1653 "timer in unexpected state");
1655 /* Now, test that referencing the same timer twice in the same call
1658 struct rte_event_timer *evtim_arr[] = {evtim, evtim};
1659 ret = rte_event_timer_cancel_burst(adapter, evtim_arr,
1660 RTE_DIM(evtim_arr));
1662 /* Two requests to cancel same timer, only one should succeed */
1663 TEST_ASSERT_EQUAL(ret, 1, "Succeeded unexpectedly in canceling timer "
1666 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1667 "after double-cancel: rte_errno = %d", rte_errno);
1671 /* Still make sure that no expiry event was generated */
1672 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1673 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n");
1675 rte_mempool_put(eventdev_test_mempool, evtim);
1677 return TEST_SUCCESS;
1680 /* Check that event timer adapter tick resolution works as expected by testing
1681 * the number of adapter ticks that occur within a particular time interval.
1684 adapter_tick_resolution(void)
1686 struct rte_event_timer_adapter_stats stats;
1687 uint64_t adapter_tick_count;
1689 /* Only run this test in the software driver case */
1690 if (!using_services)
1693 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_reset(timdev),
1694 "Failed to reset stats");
1696 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev,
1697 &stats), "Failed to get adapter stats");
1698 TEST_ASSERT_EQUAL(stats.adapter_tick_count, 0, "Adapter tick count "
1701 /* Delay 1 second; should let at least 10 ticks occur with the default
1702 * adapter configuration used by this test.
1706 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev,
1707 &stats), "Failed to get adapter stats");
1709 adapter_tick_count = stats.adapter_tick_count;
1710 TEST_ASSERT(adapter_tick_count >= 10 && adapter_tick_count <= 12,
1711 "Expected 10-12 adapter ticks, got %"PRIu64"\n",
1712 adapter_tick_count);
1714 return TEST_SUCCESS;
1718 adapter_create_max(void)
1721 uint32_t svc_start_count, svc_end_count;
1722 struct rte_event_timer_adapter *adapters[
1723 RTE_EVENT_TIMER_ADAPTER_NUM_MAX + 1];
1725 struct rte_event_timer_adapter_conf conf = {
1726 .event_dev_id = evdev,
1727 // timer_adapter_id set in loop
1728 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
1729 .timer_tick_ns = NSECPERSEC / 10,
1730 .max_tmo_ns = 180 * NSECPERSEC,
1731 .nb_timers = MAX_TIMERS,
1732 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
1735 if (!using_services)
1738 svc_start_count = rte_service_get_count();
1740 /* This test expects that there are sufficient service IDs available
1741 * to be allocated. I.e., RTE_EVENT_TIMER_ADAPTER_NUM_MAX may need to
1742 * be less than RTE_SERVICE_NUM_MAX if anything else uses a service
1743 * (the SW event device, for example).
1745 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) {
1746 conf.timer_adapter_id = i;
1747 adapters[i] = rte_event_timer_adapter_create_ext(&conf,
1748 test_port_conf_cb, NULL);
1749 TEST_ASSERT_NOT_NULL(adapters[i], "Failed to create adapter "
1753 conf.timer_adapter_id = i;
1754 adapters[i] = rte_event_timer_adapter_create(&conf);
1755 TEST_ASSERT_NULL(adapters[i], "Created too many adapters");
1757 /* Check that at least RTE_EVENT_TIMER_ADAPTER_NUM_MAX services
1760 svc_end_count = rte_service_get_count();
1761 TEST_ASSERT_EQUAL(svc_end_count - svc_start_count,
1762 RTE_EVENT_TIMER_ADAPTER_NUM_MAX,
1763 "Failed to create expected number of services");
1765 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++)
1766 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapters[i]),
1767 "Failed to free adapter %d", i);
1769 /* Check that service count is back to where it was at start */
1770 svc_end_count = rte_service_get_count();
1771 TEST_ASSERT_EQUAL(svc_start_count, svc_end_count, "Failed to release "
1772 "correct number of services");
1774 return TEST_SUCCESS;
1777 static struct unit_test_suite event_timer_adptr_functional_testsuite = {
1778 .suite_name = "event timer functional test suite",
1779 .setup = testsuite_setup,
1780 .teardown = testsuite_teardown,
1781 .unit_test_cases = {
1782 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1784 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1786 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1787 test_timer_arm_burst),
1788 TEST_CASE_ST(timdev_setup_sec, timdev_teardown,
1790 TEST_CASE_ST(timdev_setup_sec, timdev_teardown,
1791 test_timer_cancel_random),
1792 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown,
1793 test_timer_arm_multicore),
1794 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown,
1795 test_timer_arm_burst_multicore),
1796 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown,
1797 test_timer_cancel_multicore),
1798 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown,
1799 test_timer_cancel_burst_multicore),
1800 TEST_CASE(adapter_create),
1801 TEST_CASE_ST(timdev_setup_msec, NULL, adapter_free),
1802 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1804 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1806 TEST_CASE_ST(NULL, timdev_teardown,
1808 TEST_CASE_ST(timdev_setup_msec, NULL,
1810 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1811 stat_inc_reset_ev_enq),
1812 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1814 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1815 event_timer_arm_double),
1816 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1817 event_timer_arm_expiry),
1818 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1819 event_timer_arm_rearm),
1820 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1821 event_timer_arm_max),
1822 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1823 event_timer_arm_invalid_sched_type),
1824 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1825 event_timer_arm_invalid_timeout),
1826 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1827 event_timer_cancel),
1828 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1829 event_timer_cancel_double),
1830 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1831 adapter_tick_resolution),
1832 TEST_CASE(adapter_create_max),
1833 TEST_CASES_END() /**< NULL terminate unit test array */
1838 test_event_timer_adapter_func(void)
1840 return unit_test_suite_runner(&event_timer_adptr_functional_testsuite);
1843 REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func);