1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Cavium, Inc
3 * Copyright(c) 2017-2018 Intel Corporation.
10 #include <rte_common.h>
11 #include <rte_cycles.h>
12 #include <rte_debug.h>
14 #include <rte_ethdev.h>
16 #ifdef RTE_EXEC_ENV_WINDOWS
18 test_event_timer_adapter_func(void)
20 printf("event_timer_adapter not supported on Windows, skipping test\n");
26 #include <rte_eventdev.h>
27 #include <rte_event_timer_adapter.h>
28 #include <rte_mempool.h>
29 #include <rte_launch.h>
30 #include <rte_lcore.h>
31 #include <rte_per_lcore.h>
32 #include <rte_random.h>
33 #include <rte_bus_vdev.h>
34 #include <rte_service.h>
37 /* 4K timers corresponds to sw evdev max inflight events */
38 #define MAX_TIMERS (4 * 1024)
41 #define NSECPERSEC 1E9
43 /* Both the app lcore and adapter ports are linked to this queue */
44 #define TEST_QUEUE_ID 0
45 /* Port the application dequeues from */
46 #define TEST_PORT_ID 0
47 #define TEST_ADAPTER_ID 0
49 /* Handle log statements in same manner as test macros */
50 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__)
53 static struct rte_event_timer_adapter *timdev;
54 static struct rte_mempool *eventdev_test_mempool;
55 static struct rte_ring *timer_producer_ring;
56 static uint64_t global_bkt_tck_ns;
57 static uint64_t global_info_bkt_tck_ns;
58 static volatile uint8_t arm_done;
60 #define CALC_TICKS(tks) \
61 ceil((double)(tks * global_bkt_tck_ns) / global_info_bkt_tck_ns)
64 static bool using_services;
65 static uint32_t test_lcore1;
66 static uint32_t test_lcore2;
67 static uint32_t test_lcore3;
68 static uint32_t sw_evdev_slcore;
69 static uint32_t sw_adptr_slcore;
72 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
73 struct rte_event_dev_info *info)
75 memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
76 dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
77 dev_conf->nb_event_ports = 1;
78 dev_conf->nb_event_queues = 1;
79 dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
80 dev_conf->nb_event_port_dequeue_depth =
81 info->max_event_port_dequeue_depth;
82 dev_conf->nb_event_port_enqueue_depth =
83 info->max_event_port_enqueue_depth;
84 dev_conf->nb_event_port_enqueue_depth =
85 info->max_event_port_enqueue_depth;
86 dev_conf->nb_events_limit =
94 struct rte_event_dev_config dev_conf;
95 struct rte_event_dev_info info;
98 ret = rte_event_dev_info_get(evdev, &info);
99 TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
100 TEST_ASSERT(info.max_num_events < 0 ||
101 info.max_num_events >= (int32_t)MAX_TIMERS,
102 "ERROR max_num_events=%d < max_events=%d",
103 info.max_num_events, MAX_TIMERS);
105 devconf_set_default_sane_values(&dev_conf, &info);
106 ret = rte_event_dev_configure(evdev, &dev_conf);
107 TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
109 ret = rte_event_queue_setup(evdev, 0, NULL);
110 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", 0);
112 /* Configure event port */
113 ret = rte_event_port_setup(evdev, 0, NULL);
114 TEST_ASSERT_SUCCESS(ret, "Failed to setup port=%d", 0);
115 ret = rte_event_port_link(evdev, 0, NULL, NULL, 0);
116 TEST_ASSERT(ret >= 0, "Failed to link all queues port=%d", 0);
118 /* If this is a software event device, map and start its service */
119 if (rte_event_dev_service_id_get(evdev, &service_id) == 0) {
120 TEST_ASSERT_SUCCESS(rte_service_lcore_add(sw_evdev_slcore),
121 "Failed to add service core");
122 TEST_ASSERT_SUCCESS(rte_service_lcore_start(
124 "Failed to start service core");
125 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(
126 service_id, sw_evdev_slcore, 1),
127 "Failed to map evdev service");
128 TEST_ASSERT_SUCCESS(rte_service_runstate_set(
130 "Failed to start evdev service");
133 ret = rte_event_dev_start(evdev);
134 TEST_ASSERT_SUCCESS(ret, "Failed to start device");
140 testsuite_setup(void)
142 /* Some of the multithreaded tests require 3 other lcores to run */
143 unsigned int required_lcore_count = 4;
146 /* To make it easier to map services later if needed, just reset
147 * service core state.
149 (void) rte_service_lcore_reset_all();
151 if (!rte_event_dev_count()) {
152 /* If there is no hardware eventdev, or no software vdev was
153 * specified on the command line, create an instance of
156 LOG_DBG("Failed to find a valid event device... testing with"
157 " event_sw device\n");
158 TEST_ASSERT_SUCCESS(rte_vdev_init("event_sw0", NULL),
159 "Error creating eventdev");
160 evdev = rte_event_dev_get_dev_id("event_sw0");
163 if (rte_event_dev_service_id_get(evdev, &service_id) == 0) {
164 /* A software event device will use a software event timer
165 * adapter as well. 2 more cores required to convert to
168 required_lcore_count += 2;
169 using_services = true;
172 if (rte_lcore_count() < required_lcore_count) {
173 printf("Not enough cores for event_timer_adapter_test, expecting at least %u\n",
174 required_lcore_count);
178 /* Assign lcores for various tasks */
179 test_lcore1 = rte_get_next_lcore(-1, 1, 0);
180 test_lcore2 = rte_get_next_lcore(test_lcore1, 1, 0);
181 test_lcore3 = rte_get_next_lcore(test_lcore2, 1, 0);
182 if (using_services) {
183 sw_evdev_slcore = rte_get_next_lcore(test_lcore3, 1, 0);
184 sw_adptr_slcore = rte_get_next_lcore(sw_evdev_slcore, 1, 0);
187 return eventdev_setup();
191 testsuite_teardown(void)
193 rte_event_dev_stop(evdev);
194 rte_event_dev_close(evdev);
198 setup_adapter_service(struct rte_event_timer_adapter *adptr)
200 uint32_t adapter_service_id;
203 /* retrieve service ids */
204 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_service_id_get(adptr,
205 &adapter_service_id), "Failed to get event timer "
206 "adapter service id");
207 /* add a service core and start it */
208 ret = rte_service_lcore_add(sw_adptr_slcore);
209 TEST_ASSERT(ret == 0 || ret == -EALREADY,
210 "Failed to add service core");
211 ret = rte_service_lcore_start(sw_adptr_slcore);
212 TEST_ASSERT(ret == 0 || ret == -EALREADY,
213 "Failed to start service core");
215 /* map services to it */
216 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(adapter_service_id,
218 "Failed to map adapter service");
220 /* set services to running */
221 TEST_ASSERT_SUCCESS(rte_service_runstate_set(adapter_service_id, 1),
222 "Failed to start event timer adapter service");
228 test_port_conf_cb(uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id,
231 struct rte_event_dev_config dev_conf;
232 struct rte_event_dev_info info;
233 struct rte_event_port_conf *port_conf, def_port_conf = {0};
235 static int port_allocated;
236 static uint8_t port_id;
239 if (port_allocated) {
240 *event_port_id = port_id;
246 ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED,
252 rte_event_dev_stop(event_dev_id);
254 ret = rte_event_dev_info_get(evdev, &info);
258 devconf_set_default_sane_values(&dev_conf, &info);
260 port_id = dev_conf.nb_event_ports;
261 dev_conf.nb_event_ports++;
263 ret = rte_event_dev_configure(event_dev_id, &dev_conf);
266 rte_event_dev_start(event_dev_id);
270 if (conf_arg != NULL)
271 port_conf = conf_arg;
273 port_conf = &def_port_conf;
274 ret = rte_event_port_default_conf_get(event_dev_id, port_id,
280 ret = rte_event_port_setup(event_dev_id, port_id, port_conf);
284 *event_port_id = port_id;
287 rte_event_dev_start(event_dev_id);
289 /* Reuse this port number next time this is called */
296 _timdev_setup(uint64_t max_tmo_ns, uint64_t bkt_tck_ns, uint64_t flags)
298 struct rte_event_timer_adapter_info info;
299 struct rte_event_timer_adapter_conf config = {
300 .event_dev_id = evdev,
301 .timer_adapter_id = TEST_ADAPTER_ID,
302 .timer_tick_ns = bkt_tck_ns,
303 .max_tmo_ns = max_tmo_ns,
304 .nb_timers = MAX_TIMERS * 10,
308 const char *pool_name = "timdev_test_pool";
310 global_bkt_tck_ns = bkt_tck_ns;
312 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps),
313 "failed to get adapter capabilities");
315 if (flags & RTE_EVENT_TIMER_ADAPTER_F_PERIODIC &&
316 !(caps & RTE_EVENT_TIMER_ADAPTER_CAP_PERIODIC))
319 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) {
320 timdev = rte_event_timer_adapter_create_ext(&config,
323 setup_adapter_service(timdev);
324 using_services = true;
326 timdev = rte_event_timer_adapter_create(&config);
328 TEST_ASSERT_NOT_NULL(timdev,
329 "failed to create event timer ring");
331 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), 0,
332 "failed to Start event timer adapter");
334 /* Create event timer mempool */
335 eventdev_test_mempool = rte_mempool_create(pool_name,
337 sizeof(struct rte_event_timer), /* element size*/
339 0, NULL, NULL, NULL, NULL,
341 if (!eventdev_test_mempool) {
342 printf("ERROR creating mempool\n");
346 rte_event_timer_adapter_get_info(timdev, &info);
348 global_info_bkt_tck_ns = info.min_resolution_ns;
354 timdev_setup_usec(void)
356 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
358 return using_services ?
359 /* Max timeout is 10,000us and bucket interval is 100us */
360 _timdev_setup(1E7, 1E5, flags) :
361 /* Max timeout is 100us and bucket interval is 1us */
362 _timdev_setup(1E5, 1E3, flags);
366 timdev_setup_usec_multicore(void)
368 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
370 return using_services ?
371 /* Max timeout is 10,000us and bucket interval is 100us */
372 _timdev_setup(1E7, 1E5, flags) :
373 /* Max timeout is 100us and bucket interval is 1us */
374 _timdev_setup(1E5, 1E3, flags);
378 timdev_setup_msec(void)
380 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
382 /* Max timeout is 3 mins, and bucket interval is 100 ms */
383 return _timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10, flags);
387 timdev_setup_msec_periodic(void)
389 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES |
390 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC;
392 /* Periodic mode with 100 ms resolution */
393 return _timdev_setup(0, NSECPERSEC / 10, flags);
397 timdev_setup_sec(void)
399 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
401 /* Max timeout is 100sec and bucket interval is 1sec */
402 return _timdev_setup(1E11, 1E9, flags);
406 timdev_setup_sec_periodic(void)
408 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES |
409 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC;
411 /* Periodic mode with 1 sec resolution */
412 return _timdev_setup(0, NSECPERSEC, flags);
416 timdev_setup_sec_multicore(void)
418 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES;
420 /* Max timeout is 100sec and bucket interval is 1sec */
421 return _timdev_setup(1E11, 1E9, flags);
425 timdev_teardown(void)
427 rte_event_timer_adapter_stop(timdev);
428 rte_event_timer_adapter_free(timdev);
430 rte_mempool_free(eventdev_test_mempool);
434 test_timer_state(void)
436 struct rte_event_timer *ev_tim;
438 const struct rte_event_timer tim = {
439 .ev.op = RTE_EVENT_OP_NEW,
441 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
442 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
443 .ev.event_type = RTE_EVENT_TYPE_TIMER,
444 .state = RTE_EVENT_TIMER_NOT_ARMED,
448 rte_mempool_get(eventdev_test_mempool, (void **)&ev_tim);
450 ev_tim->ev.event_ptr = ev_tim;
451 ev_tim->timeout_ticks = CALC_TICKS(120);
453 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 0,
454 "Armed timer exceeding max_timeout.");
455 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ERROR_TOOLATE,
456 "Improper timer state set expected %d returned %d",
457 RTE_EVENT_TIMER_ERROR_TOOLATE, ev_tim->state);
459 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED;
460 ev_tim->timeout_ticks = CALC_TICKS(10);
462 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1,
463 "Failed to arm timer with proper timeout.");
464 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED,
465 "Improper timer state set expected %d returned %d",
466 RTE_EVENT_TIMER_ARMED, ev_tim->state);
471 rte_delay_us(1000 + 200);
472 TEST_ASSERT_EQUAL(rte_event_dequeue_burst(evdev, 0, &ev, 1, 0), 1,
473 "Armed timer failed to trigger.");
475 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED;
476 ev_tim->timeout_ticks = CALC_TICKS(90);
477 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1,
478 "Failed to arm timer with proper timeout.");
479 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, &ev_tim, 1),
480 1, "Failed to cancel armed timer");
481 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_CANCELED,
482 "Improper timer state set expected %d returned %d",
483 RTE_EVENT_TIMER_CANCELED, ev_tim->state);
485 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim);
491 _arm_timers(uint64_t timeout_tcks, uint64_t timers)
494 struct rte_event_timer *ev_tim;
495 const struct rte_event_timer tim = {
496 .ev.op = RTE_EVENT_OP_NEW,
498 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
499 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
500 .ev.event_type = RTE_EVENT_TYPE_TIMER,
501 .state = RTE_EVENT_TIMER_NOT_ARMED,
502 .timeout_ticks = CALC_TICKS(timeout_tcks),
505 for (i = 0; i < timers; i++) {
507 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
509 "mempool alloc failed");
511 ev_tim->ev.event_ptr = ev_tim;
513 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
514 1), 1, "Failed to arm timer %d",
522 _wait_timer_triggers(uint64_t wait_sec, uint64_t arm_count,
523 uint64_t cancel_count)
527 uint64_t wait_start, max_wait;
530 max_wait = rte_get_timer_hz() * wait_sec;
531 wait_start = rte_get_timer_cycles();
533 if (rte_get_timer_cycles() - wait_start > max_wait) {
534 if (events + cancel_count != arm_count)
535 TEST_ASSERT_SUCCESS(max_wait,
536 "Max time limit for timers exceeded.");
540 valid_event = rte_event_dequeue_burst(evdev, 0, &ev, 1, 0);
544 rte_mempool_put(eventdev_test_mempool, ev.event_ptr);
554 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS),
555 "Failed to arm timers");
556 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0),
557 "Timer triggered count doesn't match arm count");
562 test_timer_arm_periodic(void)
564 TEST_ASSERT_SUCCESS(_arm_timers(1, MAX_TIMERS),
565 "Failed to arm timers");
566 /* With a resolution of 100ms and wait time of 1sec,
567 * there will be 10 * MAX_TIMERS periodic timer triggers.
569 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, 10 * MAX_TIMERS, 0),
570 "Timer triggered count doesn't match arm count");
575 _arm_wrapper(void *arg)
579 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS),
580 "Failed to arm timers");
586 test_timer_arm_multicore(void)
589 uint32_t lcore_1 = rte_get_next_lcore(-1, 1, 0);
590 uint32_t lcore_2 = rte_get_next_lcore(lcore_1, 1, 0);
592 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_1);
593 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_2);
595 rte_eal_mp_wait_lcore();
596 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0),
597 "Timer triggered count doesn't match arm count");
604 _arm_timers_burst(uint64_t timeout_tcks, uint64_t timers)
608 struct rte_event_timer *ev_tim[MAX_BURST];
609 const struct rte_event_timer tim = {
610 .ev.op = RTE_EVENT_OP_NEW,
612 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
613 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
614 .ev.event_type = RTE_EVENT_TYPE_TIMER,
615 .state = RTE_EVENT_TIMER_NOT_ARMED,
616 .timeout_ticks = CALC_TICKS(timeout_tcks),
619 for (i = 0; i < timers / MAX_BURST; i++) {
620 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk(
621 eventdev_test_mempool,
622 (void **)ev_tim, MAX_BURST),
623 "mempool alloc failed");
625 for (j = 0; j < MAX_BURST; j++) {
627 ev_tim[j]->ev.event_ptr = ev_tim[j];
630 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev,
631 ev_tim, tim.timeout_ticks, MAX_BURST),
632 MAX_BURST, "Failed to arm timer %d", rte_errno);
639 test_timer_arm_burst(void)
641 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS),
642 "Failed to arm timers");
643 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0),
644 "Timer triggered count doesn't match arm count");
650 test_timer_arm_burst_periodic(void)
652 TEST_ASSERT_SUCCESS(_arm_timers_burst(1, MAX_TIMERS),
653 "Failed to arm timers");
654 /* With a resolution of 100ms and wait time of 1sec,
655 * there will be 10 * MAX_TIMERS periodic timer triggers.
657 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, 10 * MAX_TIMERS, 0),
658 "Timer triggered count doesn't match arm count");
664 _arm_wrapper_burst(void *arg)
668 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS),
669 "Failed to arm timers");
675 test_timer_arm_burst_multicore(void)
677 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore1);
678 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore2);
680 rte_eal_mp_wait_lcore();
681 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0),
682 "Timer triggered count doesn't match arm count");
688 test_timer_cancel_periodic(void)
691 struct rte_event_timer *ev_tim;
692 const struct rte_event_timer tim = {
693 .ev.op = RTE_EVENT_OP_NEW,
695 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
696 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
697 .ev.event_type = RTE_EVENT_TYPE_TIMER,
698 .state = RTE_EVENT_TIMER_NOT_ARMED,
699 .timeout_ticks = CALC_TICKS(1),
702 for (i = 0; i < MAX_TIMERS; i++) {
703 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
705 "mempool alloc failed");
707 ev_tim->ev.event_ptr = ev_tim;
709 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
710 1), 1, "Failed to arm timer %d",
713 rte_delay_us(100 + (i % 5000));
715 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev,
717 "Failed to cancel event timer %d", rte_errno);
718 rte_mempool_put(eventdev_test_mempool, ev_tim);
722 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
724 "Timer triggered count doesn't match arm, cancel count");
730 test_timer_cancel(void)
733 struct rte_event_timer *ev_tim;
734 const struct rte_event_timer tim = {
735 .ev.op = RTE_EVENT_OP_NEW,
737 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
738 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
739 .ev.event_type = RTE_EVENT_TYPE_TIMER,
740 .state = RTE_EVENT_TIMER_NOT_ARMED,
741 .timeout_ticks = CALC_TICKS(20),
744 for (i = 0; i < MAX_TIMERS; i++) {
745 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
747 "mempool alloc failed");
749 ev_tim->ev.event_ptr = ev_tim;
751 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
752 1), 1, "Failed to arm timer %d",
755 rte_delay_us(100 + (i % 5000));
757 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev,
759 "Failed to cancel event timer %d", rte_errno);
760 rte_mempool_put(eventdev_test_mempool, ev_tim);
764 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
766 "Timer triggered count doesn't match arm, cancel count");
772 _cancel_producer(uint64_t timeout_tcks, uint64_t timers)
775 struct rte_event_timer *ev_tim;
776 const struct rte_event_timer tim = {
777 .ev.op = RTE_EVENT_OP_NEW,
779 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
780 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
781 .ev.event_type = RTE_EVENT_TYPE_TIMER,
782 .state = RTE_EVENT_TIMER_NOT_ARMED,
783 .timeout_ticks = CALC_TICKS(timeout_tcks),
786 for (i = 0; i < timers; i++) {
787 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
789 "mempool alloc failed");
792 ev_tim->ev.event_ptr = ev_tim;
794 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
795 1), 1, "Failed to arm timer %d",
798 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED,
799 "Failed to arm event timer");
801 while (rte_ring_enqueue(timer_producer_ring, ev_tim) != 0)
809 _cancel_producer_burst(uint64_t timeout_tcks, uint64_t timers)
814 struct rte_event_timer *ev_tim[MAX_BURST];
815 const struct rte_event_timer tim = {
816 .ev.op = RTE_EVENT_OP_NEW,
818 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
819 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
820 .ev.event_type = RTE_EVENT_TYPE_TIMER,
821 .state = RTE_EVENT_TIMER_NOT_ARMED,
822 .timeout_ticks = CALC_TICKS(timeout_tcks),
826 for (i = 0; i < timers / MAX_BURST; i++) {
827 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk(
828 eventdev_test_mempool,
829 (void **)ev_tim, MAX_BURST),
830 "mempool alloc failed");
832 for (j = 0; j < MAX_BURST; j++) {
834 ev_tim[j]->ev.event_ptr = ev_tim[j];
837 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev,
838 ev_tim, tim.timeout_ticks, MAX_BURST),
839 MAX_BURST, "Failed to arm timer %d", rte_errno);
841 for (j = 0; j < MAX_BURST; j++)
842 TEST_ASSERT_EQUAL(ev_tim[j]->state,
843 RTE_EVENT_TIMER_ARMED,
844 "Event timer not armed, state = %d",
847 ret = rte_ring_enqueue_bulk(timer_producer_ring,
848 (void **)ev_tim, MAX_BURST, NULL);
849 TEST_ASSERT_EQUAL(ret, MAX_BURST,
850 "Failed to enqueue event timers to ring");
854 TEST_ASSERT_EQUAL(arm_count, MAX_TIMERS,
855 "Failed to arm expected number of event timers");
861 _cancel_producer_wrapper(void *args)
865 return _cancel_producer(20, MAX_TIMERS);
869 _cancel_producer_burst_wrapper(void *args)
873 return _cancel_producer_burst(100, MAX_TIMERS);
877 _cancel_thread(void *args)
880 struct rte_event_timer *ev_tim = NULL;
881 uint64_t cancel_count = 0;
884 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) {
885 if (rte_ring_dequeue(timer_producer_ring, (void **)&ev_tim))
888 ret = rte_event_timer_cancel_burst(timdev, &ev_tim, 1);
889 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel timer");
890 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim);
898 _cancel_burst_thread(void *args)
903 struct rte_event_timer *ev_tim[MAX_BURST];
904 uint64_t cancel_count = 0;
905 uint64_t dequeue_count = 0;
907 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) {
908 n = rte_ring_dequeue_burst(timer_producer_ring,
909 (void **)ev_tim, MAX_BURST, NULL);
915 for (i = 0; i < n; i++)
916 TEST_ASSERT_EQUAL(ev_tim[i]->state,
917 RTE_EVENT_TIMER_ARMED,
918 "Event timer not armed, state = %d",
921 ret = rte_event_timer_cancel_burst(timdev, ev_tim, n);
922 TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of "
924 rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim,
925 RTE_MIN(ret, MAX_BURST));
930 TEST_ASSERT_EQUAL(cancel_count, MAX_TIMERS,
931 "Failed to cancel expected number of timers: "
932 "expected = %d, cancel_count = %"PRIu64", "
933 "dequeue_count = %"PRIu64"\n", MAX_TIMERS,
934 cancel_count, dequeue_count);
940 test_timer_cancel_multicore(void)
943 timer_producer_ring = rte_ring_create("timer_cancel_queue",
944 MAX_TIMERS * 2, rte_socket_id(), 0);
945 TEST_ASSERT_NOT_NULL(timer_producer_ring,
946 "Unable to reserve memory for ring");
948 rte_eal_remote_launch(_cancel_thread, NULL, test_lcore3);
949 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore1);
950 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore2);
952 rte_eal_wait_lcore(test_lcore1);
953 rte_eal_wait_lcore(test_lcore2);
955 rte_eal_wait_lcore(test_lcore3);
956 rte_ring_free(timer_producer_ring);
958 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS * 2,
960 "Timer triggered count doesn't match arm count");
966 test_timer_cancel_burst_multicore(void)
969 timer_producer_ring = rte_ring_create("timer_cancel_queue",
970 MAX_TIMERS * 2, rte_socket_id(), 0);
971 TEST_ASSERT_NOT_NULL(timer_producer_ring,
972 "Unable to reserve memory for ring");
974 rte_eal_remote_launch(_cancel_burst_thread, NULL, test_lcore2);
975 rte_eal_remote_launch(_cancel_producer_burst_wrapper, NULL,
978 rte_eal_wait_lcore(test_lcore1);
980 rte_eal_wait_lcore(test_lcore2);
981 rte_ring_free(timer_producer_ring);
983 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
985 "Timer triggered count doesn't match arm count");
991 test_timer_cancel_random(void)
994 uint64_t events_canceled = 0;
995 struct rte_event_timer *ev_tim;
996 const struct rte_event_timer tim = {
997 .ev.op = RTE_EVENT_OP_NEW,
999 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1000 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1001 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1002 .state = RTE_EVENT_TIMER_NOT_ARMED,
1003 .timeout_ticks = CALC_TICKS(20),
1006 for (i = 0; i < MAX_TIMERS; i++) {
1008 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool,
1010 "mempool alloc failed");
1012 ev_tim->ev.event_ptr = ev_tim;
1014 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim,
1015 1), 1, "Failed to arm timer %d",
1018 if (rte_rand() & 1) {
1019 rte_delay_us(100 + (i % 5000));
1020 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(
1023 "Failed to cancel event timer %d", rte_errno);
1024 rte_mempool_put(eventdev_test_mempool, ev_tim);
1029 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS,
1031 "Timer triggered count doesn't match arm, cancel count");
1033 return TEST_SUCCESS;
1036 /* Check that the adapter can be created correctly */
1038 adapter_create(void)
1041 struct rte_event_timer_adapter *adapter, *adapter2;
1043 struct rte_event_timer_adapter_conf conf = {
1044 .event_dev_id = evdev + 1, // invalid event dev id
1045 .timer_adapter_id = adapter_id,
1046 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
1047 .timer_tick_ns = NSECPERSEC / 10,
1048 .max_tmo_ns = 180 * NSECPERSEC,
1049 .nb_timers = MAX_TIMERS,
1050 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
1054 /* Test invalid conf */
1055 adapter = rte_event_timer_adapter_create(&conf);
1056 TEST_ASSERT_NULL(adapter, "Created adapter with invalid "
1058 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Incorrect errno value for "
1059 "invalid event device id");
1061 /* Test valid conf */
1062 conf.event_dev_id = evdev;
1063 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps),
1064 "failed to get adapter capabilities");
1065 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT))
1066 adapter = rte_event_timer_adapter_create_ext(&conf,
1070 adapter = rte_event_timer_adapter_create(&conf);
1071 TEST_ASSERT_NOT_NULL(adapter, "Failed to create adapter with valid "
1074 /* Test existing id */
1075 adapter2 = rte_event_timer_adapter_create(&conf);
1076 TEST_ASSERT_NULL(adapter2, "Created adapter with in-use id");
1077 TEST_ASSERT(rte_errno == EEXIST, "Incorrect errno value for existing "
1080 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapter),
1081 "Failed to free adapter");
1083 return TEST_SUCCESS;
1087 /* Test that adapter can be freed correctly. */
1091 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev),
1092 "Failed to stop adapter");
1094 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev),
1095 "Failed to free valid adapter");
1097 /* Test free of already freed adapter */
1098 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev),
1099 "Freed adapter that was already freed");
1101 /* Test free of null adapter */
1103 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev),
1104 "Freed null adapter");
1106 rte_mempool_free(eventdev_test_mempool);
1108 return TEST_SUCCESS;
1111 /* Test that adapter info can be retrieved and is correct. */
1113 adapter_get_info(void)
1115 struct rte_event_timer_adapter_info info;
1117 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_get_info(timdev, &info),
1118 "Failed to get adapter info");
1121 TEST_ASSERT_EQUAL(info.event_dev_port_id, 1,
1122 "Expected port id = 1, got port id = %d",
1123 info.event_dev_port_id);
1125 return TEST_SUCCESS;
1128 /* Test adapter lookup via adapter ID. */
1130 adapter_lookup(void)
1132 struct rte_event_timer_adapter *adapter;
1134 adapter = rte_event_timer_adapter_lookup(TEST_ADAPTER_ID);
1135 TEST_ASSERT_NOT_NULL(adapter, "Failed to lookup adapter");
1137 return TEST_SUCCESS;
1143 TEST_ASSERT_SUCCESS(_timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10,
1144 RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES),
1145 "Failed to start adapter");
1146 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), -EALREADY,
1147 "Timer adapter started without call to stop.");
1149 return TEST_SUCCESS;
1152 /* Test that adapter stops correctly. */
1156 struct rte_event_timer_adapter *l_adapter = NULL;
1158 /* Test adapter stop */
1159 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev),
1160 "Failed to stop event adapter");
1162 TEST_ASSERT_FAIL(rte_event_timer_adapter_stop(l_adapter),
1163 "Erroneously stopped null event adapter");
1165 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev),
1166 "Failed to free adapter");
1168 rte_mempool_free(eventdev_test_mempool);
1170 return TEST_SUCCESS;
1173 /* Test increment and reset of ev_enq_count stat */
1175 stat_inc_reset_ev_enq(void)
1178 int num_evtims = MAX_TIMERS;
1179 struct rte_event_timer *evtims[num_evtims];
1180 struct rte_event evs[BATCH_SIZE];
1181 struct rte_event_timer_adapter_stats stats;
1182 const struct rte_event_timer init_tim = {
1183 .ev.op = RTE_EVENT_OP_NEW,
1184 .ev.queue_id = TEST_QUEUE_ID,
1185 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1186 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1187 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1188 .state = RTE_EVENT_TIMER_NOT_ARMED,
1189 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1192 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims,
1194 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d",
1197 for (i = 0; i < num_evtims; i++) {
1198 *evtims[i] = init_tim;
1199 evtims[i]->ev.event_ptr = evtims[i];
1202 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1203 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1204 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, "Stats not clear at "
1207 /* Test with the max value for the adapter */
1208 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims);
1209 TEST_ASSERT_EQUAL(ret, num_evtims,
1210 "Failed to arm all event timers: attempted = %d, "
1211 "succeeded = %d, rte_errno = %s",
1212 num_evtims, ret, rte_strerror(rte_errno));
1216 #define MAX_TRIES num_evtims
1221 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs,
1223 if (sum >= num_evtims || ++tries >= MAX_TRIES)
1229 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, "
1230 "got %d", num_evtims, sum);
1232 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries");
1236 /* Make sure the eventdev is still empty */
1237 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs),
1240 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry "
1241 "events from event device");
1243 /* Check stats again */
1244 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1245 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1246 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, num_evtims,
1247 "Expected enqueue stat = %d; got %d", num_evtims,
1248 (int)stats.ev_enq_count);
1250 /* Reset and check again */
1251 ret = rte_event_timer_adapter_stats_reset(timdev);
1252 TEST_ASSERT_EQUAL(ret, 0, "Failed to reset stats");
1254 ret = rte_event_timer_adapter_stats_get(timdev, &stats);
1255 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats");
1256 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0,
1257 "Expected enqueue stat = %d; got %d", 0,
1258 (int)stats.ev_enq_count);
1260 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims,
1263 return TEST_SUCCESS;
1266 /* Test various cases in arming timers */
1268 event_timer_arm(void)
1272 struct rte_event_timer_adapter *adapter = timdev;
1273 struct rte_event_timer *evtim = NULL;
1274 struct rte_event evs[BATCH_SIZE];
1275 const struct rte_event_timer init_tim = {
1276 .ev.op = RTE_EVENT_OP_NEW,
1277 .ev.queue_id = TEST_QUEUE_ID,
1278 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1279 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1280 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1281 .state = RTE_EVENT_TIMER_NOT_ARMED,
1282 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1285 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1286 if (evtim == NULL) {
1287 /* Failed to get an event timer object */
1291 /* Set up a timer */
1293 evtim->ev.event_ptr = evtim;
1295 /* Test single timer arm succeeds */
1296 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1297 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1298 rte_strerror(rte_errno));
1299 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event timer "
1300 "in incorrect state");
1302 /* Test arm of armed timer fails */
1303 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1304 TEST_ASSERT_EQUAL(ret, 0, "expected return value from "
1305 "rte_event_timer_arm_burst: 0, got: %d", ret);
1306 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1307 "after arming already armed timer");
1309 /* Let timer expire */
1312 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1313 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1314 "events from event device");
1316 rte_mempool_put(eventdev_test_mempool, evtim);
1318 return TEST_SUCCESS;
1321 /* This test checks that repeated references to the same event timer in the
1322 * arm request work as expected; only the first one through should succeed.
1325 event_timer_arm_double(void)
1329 struct rte_event_timer_adapter *adapter = timdev;
1330 struct rte_event_timer *evtim = NULL;
1331 struct rte_event evs[BATCH_SIZE];
1332 const struct rte_event_timer init_tim = {
1333 .ev.op = RTE_EVENT_OP_NEW,
1334 .ev.queue_id = TEST_QUEUE_ID,
1335 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1336 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1337 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1338 .state = RTE_EVENT_TIMER_NOT_ARMED,
1339 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1342 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1343 if (evtim == NULL) {
1344 /* Failed to get an event timer object */
1348 /* Set up a timer */
1350 evtim->ev.event_ptr = evtim;
1352 struct rte_event_timer *evtim_arr[] = {evtim, evtim};
1353 ret = rte_event_timer_arm_burst(adapter, evtim_arr, RTE_DIM(evtim_arr));
1354 TEST_ASSERT_EQUAL(ret, 1, "Unexpected return value from "
1355 "rte_event_timer_arm_burst");
1356 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1357 "after double-arm");
1359 /* Let timer expire */
1362 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1363 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number of expiry events - "
1364 "expected: 1, actual: %d", n);
1366 rte_mempool_put(eventdev_test_mempool, evtim);
1368 return TEST_SUCCESS;
1371 /* Test the timer expiry event is generated at the expected time. */
1373 event_timer_arm_expiry(void)
1377 struct rte_event_timer_adapter *adapter = timdev;
1378 struct rte_event_timer *evtim = NULL;
1379 struct rte_event_timer *evtim2 = NULL;
1380 struct rte_event evs[BATCH_SIZE];
1381 const struct rte_event_timer init_tim = {
1382 .ev.op = RTE_EVENT_OP_NEW,
1383 .ev.queue_id = TEST_QUEUE_ID,
1384 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1385 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1386 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1387 .state = RTE_EVENT_TIMER_NOT_ARMED,
1390 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1391 if (evtim == NULL) {
1392 /* Failed to get an event timer object */
1396 /* Set up an event timer */
1398 evtim->timeout_ticks = CALC_TICKS(30), // expire in 3 secs
1399 evtim->ev.event_ptr = evtim;
1401 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1402 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s",
1403 rte_strerror(rte_errno));
1404 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event "
1405 "timer in incorrect state");
1409 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1410 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event");
1412 /* Delay 100 ms to account for the adapter tick window - should let us
1417 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1418 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number (%d) of timer "
1419 "expiry events", n);
1420 TEST_ASSERT_EQUAL(evs[0].event_type, RTE_EVENT_TYPE_TIMER,
1421 "Dequeued unexpected type of event");
1423 /* Check that we recover the original event timer and then free it */
1424 evtim2 = evs[0].event_ptr;
1425 TEST_ASSERT_EQUAL(evtim, evtim2,
1426 "Failed to recover pointer to original event timer");
1427 rte_mempool_put(eventdev_test_mempool, evtim2);
1429 return TEST_SUCCESS;
1432 /* Check that rearming a timer works as expected. */
1434 event_timer_arm_rearm(void)
1438 struct rte_event_timer *evtim = NULL;
1439 struct rte_event_timer *evtim2 = NULL;
1440 struct rte_event evs[BATCH_SIZE];
1441 const struct rte_event_timer init_tim = {
1442 .ev.op = RTE_EVENT_OP_NEW,
1443 .ev.queue_id = TEST_QUEUE_ID,
1444 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1445 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1446 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1447 .state = RTE_EVENT_TIMER_NOT_ARMED,
1450 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1451 if (evtim == NULL) {
1452 /* Failed to get an event timer object */
1456 /* Set up a timer */
1458 evtim->timeout_ticks = CALC_TICKS(1); // expire in 0.1 sec
1459 evtim->ev.event_ptr = evtim;
1462 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1463 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1464 rte_strerror(rte_errno));
1466 /* Add 100ms to account for the adapter tick window */
1467 rte_delay_ms(100 + 100);
1469 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1470 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1471 "events from event device");
1473 /* Recover the timer through the event that was dequeued. */
1474 evtim2 = evs[0].event_ptr;
1475 TEST_ASSERT_EQUAL(evtim, evtim2,
1476 "Failed to recover pointer to original event timer");
1478 /* Need to reset state in case implementation can't do it */
1479 evtim2->state = RTE_EVENT_TIMER_NOT_ARMED;
1482 ret = rte_event_timer_arm_burst(timdev, &evtim2, 1);
1483 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1484 rte_strerror(rte_errno));
1486 /* Add 100ms to account for the adapter tick window */
1487 rte_delay_ms(100 + 100);
1489 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1490 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry "
1491 "events from event device");
1494 evtim2 = evs[0].event_ptr;
1495 TEST_ASSERT_EQUAL(evtim, evtim2,
1496 "Failed to recover pointer to original event timer");
1497 rte_mempool_put(eventdev_test_mempool, evtim2);
1499 return TEST_SUCCESS;
1502 /* Check that the adapter handles the max specified number of timers as
1506 event_timer_arm_max(void)
1509 int num_evtims = MAX_TIMERS;
1510 struct rte_event_timer *evtims[num_evtims];
1511 struct rte_event evs[BATCH_SIZE];
1512 const struct rte_event_timer init_tim = {
1513 .ev.op = RTE_EVENT_OP_NEW,
1514 .ev.queue_id = TEST_QUEUE_ID,
1515 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1516 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1517 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1518 .state = RTE_EVENT_TIMER_NOT_ARMED,
1519 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1522 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims,
1524 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d",
1527 for (i = 0; i < num_evtims; i++) {
1528 *evtims[i] = init_tim;
1529 evtims[i]->ev.event_ptr = evtims[i];
1532 /* Test with the max value for the adapter */
1533 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims);
1534 TEST_ASSERT_EQUAL(ret, num_evtims,
1535 "Failed to arm all event timers: attempted = %d, "
1536 "succeeded = %d, rte_errno = %s",
1537 num_evtims, ret, rte_strerror(rte_errno));
1541 #define MAX_TRIES num_evtims
1546 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs,
1548 if (sum >= num_evtims || ++tries >= MAX_TRIES)
1554 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, "
1555 "got %d", num_evtims, sum);
1557 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries");
1561 /* Make sure the eventdev is still empty */
1562 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs),
1565 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry "
1566 "events from event device");
1568 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims,
1571 return TEST_SUCCESS;
1574 /* Check that creating an event timer with incorrect event sched type fails. */
1576 event_timer_arm_invalid_sched_type(void)
1579 struct rte_event_timer *evtim = NULL;
1580 const struct rte_event_timer init_tim = {
1581 .ev.op = RTE_EVENT_OP_NEW,
1582 .ev.queue_id = TEST_QUEUE_ID,
1583 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1584 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1585 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1586 .state = RTE_EVENT_TIMER_NOT_ARMED,
1587 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1590 if (!using_services)
1593 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1594 if (evtim == NULL) {
1595 /* Failed to get an event timer object */
1600 evtim->ev.event_ptr = evtim;
1601 evtim->ev.sched_type = RTE_SCHED_TYPE_PARALLEL; // bad sched type
1603 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1604 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1605 "sched type, but didn't");
1606 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1607 " arm fail with invalid queue");
1609 rte_mempool_put(eventdev_test_mempool, &evtim);
1611 return TEST_SUCCESS;
1614 /* Check that creating an event timer with a timeout value that is too small or
1618 event_timer_arm_invalid_timeout(void)
1621 struct rte_event_timer *evtim = NULL;
1622 const struct rte_event_timer init_tim = {
1623 .ev.op = RTE_EVENT_OP_NEW,
1624 .ev.queue_id = TEST_QUEUE_ID,
1625 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1626 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1627 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1628 .state = RTE_EVENT_TIMER_NOT_ARMED,
1629 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1632 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1633 if (evtim == NULL) {
1634 /* Failed to get an event timer object */
1639 evtim->ev.event_ptr = evtim;
1640 evtim->timeout_ticks = 0; // timeout too small
1642 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1643 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1644 "timeout, but didn't");
1645 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1646 " arm fail with invalid timeout");
1647 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOEARLY,
1648 "Unexpected event timer state");
1651 evtim->ev.event_ptr = evtim;
1652 evtim->timeout_ticks = CALC_TICKS(1801); // timeout too big
1654 ret = rte_event_timer_arm_burst(timdev, &evtim, 1);
1655 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid "
1656 "timeout, but didn't");
1657 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after"
1658 " arm fail with invalid timeout");
1659 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOLATE,
1660 "Unexpected event timer state");
1662 rte_mempool_put(eventdev_test_mempool, evtim);
1664 return TEST_SUCCESS;
1668 event_timer_cancel(void)
1672 struct rte_event_timer_adapter *adapter = timdev;
1673 struct rte_event_timer *evtim = NULL;
1674 struct rte_event evs[BATCH_SIZE];
1675 const struct rte_event_timer init_tim = {
1676 .ev.op = RTE_EVENT_OP_NEW,
1677 .ev.queue_id = TEST_QUEUE_ID,
1678 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1679 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1680 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1681 .state = RTE_EVENT_TIMER_NOT_ARMED,
1684 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1685 if (evtim == NULL) {
1686 /* Failed to get an event timer object */
1690 /* Check that cancelling an uninited timer fails */
1691 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1692 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling "
1694 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after "
1695 "cancelling uninited timer");
1697 /* Set up a timer */
1699 evtim->ev.event_ptr = evtim;
1700 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec
1702 /* Check that cancelling an inited but unarmed timer fails */
1703 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1704 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling "
1706 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after "
1707 "cancelling unarmed timer");
1709 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1710 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1711 rte_strerror(rte_errno));
1712 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED,
1713 "evtim in incorrect state");
1718 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1);
1719 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel event_timer: %s\n",
1720 rte_strerror(rte_errno));
1721 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_CANCELED,
1722 "evtim in incorrect state");
1726 /* Make sure that no expiry event was generated */
1727 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1728 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n");
1730 rte_mempool_put(eventdev_test_mempool, evtim);
1732 return TEST_SUCCESS;
1736 event_timer_cancel_double(void)
1740 struct rte_event_timer_adapter *adapter = timdev;
1741 struct rte_event_timer *evtim = NULL;
1742 struct rte_event evs[BATCH_SIZE];
1743 const struct rte_event_timer init_tim = {
1744 .ev.op = RTE_EVENT_OP_NEW,
1745 .ev.queue_id = TEST_QUEUE_ID,
1746 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC,
1747 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL,
1748 .ev.event_type = RTE_EVENT_TYPE_TIMER,
1749 .state = RTE_EVENT_TIMER_NOT_ARMED,
1750 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec
1753 rte_mempool_get(eventdev_test_mempool, (void **)&evtim);
1754 if (evtim == NULL) {
1755 /* Failed to get an event timer object */
1759 /* Set up a timer */
1761 evtim->ev.event_ptr = evtim;
1762 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec
1764 ret = rte_event_timer_arm_burst(adapter, &evtim, 1);
1765 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n",
1766 rte_strerror(rte_errno));
1767 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED,
1768 "timer in unexpected state");
1770 /* Now, test that referencing the same timer twice in the same call
1773 struct rte_event_timer *evtim_arr[] = {evtim, evtim};
1774 ret = rte_event_timer_cancel_burst(adapter, evtim_arr,
1775 RTE_DIM(evtim_arr));
1777 /* Two requests to cancel same timer, only one should succeed */
1778 TEST_ASSERT_EQUAL(ret, 1, "Succeeded unexpectedly in canceling timer "
1781 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value "
1782 "after double-cancel: rte_errno = %d", rte_errno);
1786 /* Still make sure that no expiry event was generated */
1787 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0);
1788 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n");
1790 rte_mempool_put(eventdev_test_mempool, evtim);
1792 return TEST_SUCCESS;
1795 /* Check that event timer adapter tick resolution works as expected by testing
1796 * the number of adapter ticks that occur within a particular time interval.
1799 adapter_tick_resolution(void)
1801 struct rte_event_timer_adapter_stats stats;
1802 uint64_t adapter_tick_count;
1804 /* Only run this test in the software driver case */
1805 if (!using_services)
1808 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_reset(timdev),
1809 "Failed to reset stats");
1811 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev,
1812 &stats), "Failed to get adapter stats");
1813 TEST_ASSERT_EQUAL(stats.adapter_tick_count, 0, "Adapter tick count "
1816 /* Delay 1 second; should let at least 10 ticks occur with the default
1817 * adapter configuration used by this test.
1821 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev,
1822 &stats), "Failed to get adapter stats");
1824 adapter_tick_count = stats.adapter_tick_count;
1825 TEST_ASSERT(adapter_tick_count >= 10 && adapter_tick_count <= 12,
1826 "Expected 10-12 adapter ticks, got %"PRIu64"\n",
1827 adapter_tick_count);
1829 return TEST_SUCCESS;
1833 adapter_create_max(void)
1836 uint32_t svc_start_count, svc_end_count;
1837 struct rte_event_timer_adapter *adapters[
1838 RTE_EVENT_TIMER_ADAPTER_NUM_MAX + 1];
1840 struct rte_event_timer_adapter_conf conf = {
1841 .event_dev_id = evdev,
1842 // timer_adapter_id set in loop
1843 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK,
1844 .timer_tick_ns = NSECPERSEC / 10,
1845 .max_tmo_ns = 180 * NSECPERSEC,
1846 .nb_timers = MAX_TIMERS,
1847 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES,
1850 if (!using_services)
1853 svc_start_count = rte_service_get_count();
1855 /* This test expects that there are sufficient service IDs available
1856 * to be allocated. I.e., RTE_EVENT_TIMER_ADAPTER_NUM_MAX may need to
1857 * be less than RTE_SERVICE_NUM_MAX if anything else uses a service
1858 * (the SW event device, for example).
1860 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) {
1861 conf.timer_adapter_id = i;
1862 adapters[i] = rte_event_timer_adapter_create_ext(&conf,
1863 test_port_conf_cb, NULL);
1864 TEST_ASSERT_NOT_NULL(adapters[i], "Failed to create adapter "
1868 conf.timer_adapter_id = i;
1869 adapters[i] = rte_event_timer_adapter_create(&conf);
1870 TEST_ASSERT_NULL(adapters[i], "Created too many adapters");
1872 /* Check that at least RTE_EVENT_TIMER_ADAPTER_NUM_MAX services
1875 svc_end_count = rte_service_get_count();
1876 TEST_ASSERT_EQUAL(svc_end_count - svc_start_count,
1877 RTE_EVENT_TIMER_ADAPTER_NUM_MAX,
1878 "Failed to create expected number of services");
1880 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++)
1881 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapters[i]),
1882 "Failed to free adapter %d", i);
1884 /* Check that service count is back to where it was at start */
1885 svc_end_count = rte_service_get_count();
1886 TEST_ASSERT_EQUAL(svc_start_count, svc_end_count, "Failed to release "
1887 "correct number of services");
1889 return TEST_SUCCESS;
1892 static struct unit_test_suite event_timer_adptr_functional_testsuite = {
1893 .suite_name = "event timer functional test suite",
1894 .setup = testsuite_setup,
1895 .teardown = testsuite_teardown,
1896 .unit_test_cases = {
1897 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1899 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1901 TEST_CASE_ST(timdev_setup_msec_periodic, timdev_teardown,
1902 test_timer_arm_periodic),
1903 TEST_CASE_ST(timdev_setup_usec, timdev_teardown,
1904 test_timer_arm_burst),
1905 TEST_CASE_ST(timdev_setup_msec_periodic, timdev_teardown,
1906 test_timer_arm_burst_periodic),
1907 TEST_CASE_ST(timdev_setup_sec, timdev_teardown,
1909 TEST_CASE_ST(timdev_setup_sec_periodic, timdev_teardown,
1910 test_timer_cancel_periodic),
1911 TEST_CASE_ST(timdev_setup_sec, timdev_teardown,
1912 test_timer_cancel_random),
1913 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown,
1914 test_timer_arm_multicore),
1915 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown,
1916 test_timer_arm_burst_multicore),
1917 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown,
1918 test_timer_cancel_multicore),
1919 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown,
1920 test_timer_cancel_burst_multicore),
1921 TEST_CASE(adapter_create),
1922 TEST_CASE_ST(timdev_setup_msec, NULL, adapter_free),
1923 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1925 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1927 TEST_CASE_ST(NULL, timdev_teardown,
1929 TEST_CASE_ST(timdev_setup_msec, NULL,
1931 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1932 stat_inc_reset_ev_enq),
1933 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1935 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1936 event_timer_arm_double),
1937 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1938 event_timer_arm_expiry),
1939 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1940 event_timer_arm_rearm),
1941 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1942 event_timer_arm_max),
1943 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1944 event_timer_arm_invalid_sched_type),
1945 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1946 event_timer_arm_invalid_timeout),
1947 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1948 event_timer_cancel),
1949 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1950 event_timer_cancel_double),
1951 TEST_CASE_ST(timdev_setup_msec, timdev_teardown,
1952 adapter_tick_resolution),
1953 TEST_CASE(adapter_create_max),
1954 TEST_CASES_END() /**< NULL terminate unit test array */
1959 test_event_timer_adapter_func(void)
1961 return unit_test_suite_runner(&event_timer_adptr_functional_testsuite);
1964 #endif /* !RTE_EXEC_ENV_WINDOWS */
1966 REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func);