1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Cavium, Inc 3 * Copyright(c) 2017-2018 Intel Corporation. 4 */ 5 6 #include <rte_atomic.h> 7 #include <rte_common.h> 8 #include <rte_cycles.h> 9 #include <rte_debug.h> 10 #include <rte_eal.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> 21 #include <stdbool.h> 22 23 #include "test.h" 24 25 /* 4K timers corresponds to sw evdev max inflight events */ 26 #define MAX_TIMERS (4 * 1024) 27 #define BKT_TCK_NSEC 28 29 #define NSECPERSEC 1E9 30 #define BATCH_SIZE 16 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 36 37 /* Handle log statements in same manner as test macros */ 38 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__) 39 40 static int evdev; 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; 47 48 #define CALC_TICKS(tks) \ 49 ((tks * global_bkt_tck_ns) / global_info_bkt_tck_ns) 50 51 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; 58 59 static inline void 60 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf, 61 struct rte_event_dev_info *info) 62 { 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 = 75 info->max_num_events; 76 } 77 78 static inline int 79 eventdev_setup(void) 80 { 81 int ret; 82 struct rte_event_dev_config dev_conf; 83 struct rte_event_dev_info info; 84 uint32_t service_id; 85 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); 92 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"); 96 97 ret = rte_event_queue_setup(evdev, 0, NULL); 98 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", 0); 99 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); 105 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( 111 sw_evdev_slcore), 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( 117 service_id, 1), 118 "Failed to start evdev service"); 119 } 120 121 ret = rte_event_dev_start(evdev); 122 TEST_ASSERT_SUCCESS(ret, "Failed to start device"); 123 124 return TEST_SUCCESS; 125 } 126 127 static int 128 testsuite_setup(void) 129 { 130 /* Some of the multithreaded tests require 3 other lcores to run */ 131 unsigned int required_lcore_count = 4; 132 uint32_t service_id; 133 134 /* To make it easier to map services later if needed, just reset 135 * service core state. 136 */ 137 (void) rte_service_lcore_reset_all(); 138 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 142 * event_sw. 143 */ 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"); 149 } 150 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 154 * service cores. 155 */ 156 required_lcore_count += 2; 157 using_services = true; 158 } 159 160 if (rte_lcore_count() < required_lcore_count) { 161 printf("Not enough cores for event_timer_adapter_test, expecting at least %u\n", 162 required_lcore_count); 163 return TEST_SKIPPED; 164 } 165 166 /* Assign lcores for various tasks */ 167 test_lcore1 = rte_get_next_lcore(-1, 1, 0); 168 test_lcore2 = rte_get_next_lcore(test_lcore1, 1, 0); 169 test_lcore3 = rte_get_next_lcore(test_lcore2, 1, 0); 170 if (using_services) { 171 sw_evdev_slcore = rte_get_next_lcore(test_lcore3, 1, 0); 172 sw_adptr_slcore = rte_get_next_lcore(sw_evdev_slcore, 1, 0); 173 } 174 175 return eventdev_setup(); 176 } 177 178 static void 179 testsuite_teardown(void) 180 { 181 rte_event_dev_stop(evdev); 182 rte_event_dev_close(evdev); 183 } 184 185 static int 186 setup_adapter_service(struct rte_event_timer_adapter *adptr) 187 { 188 uint32_t adapter_service_id; 189 int ret; 190 191 /* retrieve service ids */ 192 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_service_id_get(adptr, 193 &adapter_service_id), "Failed to get event timer " 194 "adapter service id"); 195 /* add a service core and start it */ 196 ret = rte_service_lcore_add(sw_adptr_slcore); 197 TEST_ASSERT(ret == 0 || ret == -EALREADY, 198 "Failed to add service core"); 199 ret = rte_service_lcore_start(sw_adptr_slcore); 200 TEST_ASSERT(ret == 0 || ret == -EALREADY, 201 "Failed to start service core"); 202 203 /* map services to it */ 204 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(adapter_service_id, 205 sw_adptr_slcore, 1), 206 "Failed to map adapter service"); 207 208 /* set services to running */ 209 TEST_ASSERT_SUCCESS(rte_service_runstate_set(adapter_service_id, 1), 210 "Failed to start event timer adapter service"); 211 212 return TEST_SUCCESS; 213 } 214 215 static int 216 test_port_conf_cb(uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id, 217 void *conf_arg) 218 { 219 struct rte_event_dev_config dev_conf; 220 struct rte_event_dev_info info; 221 struct rte_event_port_conf *port_conf, def_port_conf = {0}; 222 uint32_t started; 223 static int port_allocated; 224 static uint8_t port_id; 225 int ret; 226 227 if (port_allocated) { 228 *event_port_id = port_id; 229 return 0; 230 } 231 232 RTE_SET_USED(id); 233 234 ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED, 235 &started); 236 if (ret < 0) 237 return ret; 238 239 if (started) 240 rte_event_dev_stop(event_dev_id); 241 242 ret = rte_event_dev_info_get(evdev, &info); 243 if (ret < 0) 244 return ret; 245 246 devconf_set_default_sane_values(&dev_conf, &info); 247 248 port_id = dev_conf.nb_event_ports; 249 dev_conf.nb_event_ports++; 250 251 ret = rte_event_dev_configure(event_dev_id, &dev_conf); 252 if (ret < 0) { 253 if (started) 254 rte_event_dev_start(event_dev_id); 255 return ret; 256 } 257 258 if (conf_arg != NULL) 259 port_conf = conf_arg; 260 else { 261 port_conf = &def_port_conf; 262 ret = rte_event_port_default_conf_get(event_dev_id, port_id, 263 port_conf); 264 if (ret < 0) 265 return ret; 266 } 267 268 ret = rte_event_port_setup(event_dev_id, port_id, port_conf); 269 if (ret < 0) 270 return ret; 271 272 *event_port_id = port_id; 273 274 if (started) 275 rte_event_dev_start(event_dev_id); 276 277 /* Reuse this port number next time this is called */ 278 port_allocated = 1; 279 280 return 0; 281 } 282 283 static int 284 _timdev_setup(uint64_t max_tmo_ns, uint64_t bkt_tck_ns) 285 { 286 struct rte_event_timer_adapter_info info; 287 struct rte_event_timer_adapter_conf config = { 288 .event_dev_id = evdev, 289 .timer_adapter_id = TEST_ADAPTER_ID, 290 .timer_tick_ns = bkt_tck_ns, 291 .max_tmo_ns = max_tmo_ns, 292 .nb_timers = MAX_TIMERS * 10, 293 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, 294 }; 295 uint32_t caps = 0; 296 const char *pool_name = "timdev_test_pool"; 297 298 global_bkt_tck_ns = bkt_tck_ns; 299 300 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 301 "failed to get adapter capabilities"); 302 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) { 303 timdev = rte_event_timer_adapter_create_ext(&config, 304 test_port_conf_cb, 305 NULL); 306 setup_adapter_service(timdev); 307 using_services = true; 308 } else 309 timdev = rte_event_timer_adapter_create(&config); 310 311 TEST_ASSERT_NOT_NULL(timdev, 312 "failed to create event timer ring"); 313 314 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), 0, 315 "failed to Start event timer adapter"); 316 317 /* Create event timer mempool */ 318 eventdev_test_mempool = rte_mempool_create(pool_name, 319 MAX_TIMERS * 2, 320 sizeof(struct rte_event_timer), /* element size*/ 321 0, /* cache size*/ 322 0, NULL, NULL, NULL, NULL, 323 rte_socket_id(), 0); 324 if (!eventdev_test_mempool) { 325 printf("ERROR creating mempool\n"); 326 return TEST_FAILED; 327 } 328 329 rte_event_timer_adapter_get_info(timdev, &info); 330 331 global_info_bkt_tck_ns = info.min_resolution_ns; 332 333 return TEST_SUCCESS; 334 } 335 336 static int 337 timdev_setup_usec(void) 338 { 339 return using_services ? 340 /* Max timeout is 10,000us and bucket interval is 100us */ 341 _timdev_setup(1E7, 1E5) : 342 /* Max timeout is 100us and bucket interval is 1us */ 343 _timdev_setup(1E5, 1E3); 344 } 345 346 static int 347 timdev_setup_usec_multicore(void) 348 { 349 return using_services ? 350 /* Max timeout is 10,000us and bucket interval is 100us */ 351 _timdev_setup(1E7, 1E5) : 352 /* Max timeout is 100us and bucket interval is 1us */ 353 _timdev_setup(1E5, 1E3); 354 } 355 356 static int 357 timdev_setup_msec(void) 358 { 359 /* Max timeout is 2 mins, and bucket interval is 100 ms */ 360 return _timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10); 361 } 362 363 static int 364 timdev_setup_sec(void) 365 { 366 /* Max timeout is 100sec and bucket interval is 1sec */ 367 return _timdev_setup(1E11, 1E9); 368 } 369 370 static int 371 timdev_setup_sec_multicore(void) 372 { 373 /* Max timeout is 100sec and bucket interval is 1sec */ 374 return _timdev_setup(1E11, 1E9); 375 } 376 377 static void 378 timdev_teardown(void) 379 { 380 rte_event_timer_adapter_stop(timdev); 381 rte_event_timer_adapter_free(timdev); 382 383 rte_mempool_free(eventdev_test_mempool); 384 } 385 386 static inline int 387 test_timer_state(void) 388 { 389 struct rte_event_timer *ev_tim; 390 struct rte_event ev; 391 const struct rte_event_timer tim = { 392 .ev.op = RTE_EVENT_OP_NEW, 393 .ev.queue_id = 0, 394 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 395 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 396 .ev.event_type = RTE_EVENT_TYPE_TIMER, 397 .state = RTE_EVENT_TIMER_NOT_ARMED, 398 }; 399 400 401 rte_mempool_get(eventdev_test_mempool, (void **)&ev_tim); 402 *ev_tim = tim; 403 ev_tim->ev.event_ptr = ev_tim; 404 ev_tim->timeout_ticks = CALC_TICKS(120); 405 406 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 0, 407 "Armed timer exceeding max_timeout."); 408 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ERROR_TOOLATE, 409 "Improper timer state set expected %d returned %d", 410 RTE_EVENT_TIMER_ERROR_TOOLATE, ev_tim->state); 411 412 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED; 413 ev_tim->timeout_ticks = CALC_TICKS(10); 414 415 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1, 416 "Failed to arm timer with proper timeout."); 417 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED, 418 "Improper timer state set expected %d returned %d", 419 RTE_EVENT_TIMER_ARMED, ev_tim->state); 420 421 if (!using_services) 422 rte_delay_us(20); 423 else 424 rte_delay_us(1000 + 200); 425 TEST_ASSERT_EQUAL(rte_event_dequeue_burst(evdev, 0, &ev, 1, 0), 1, 426 "Armed timer failed to trigger."); 427 428 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED; 429 ev_tim->timeout_ticks = CALC_TICKS(90); 430 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1, 431 "Failed to arm timer with proper timeout."); 432 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, &ev_tim, 1), 433 1, "Failed to cancel armed timer"); 434 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_CANCELED, 435 "Improper timer state set expected %d returned %d", 436 RTE_EVENT_TIMER_CANCELED, ev_tim->state); 437 438 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim); 439 440 return TEST_SUCCESS; 441 } 442 443 static inline int 444 _arm_timers(uint64_t timeout_tcks, uint64_t timers) 445 { 446 uint64_t i; 447 struct rte_event_timer *ev_tim; 448 const struct rte_event_timer tim = { 449 .ev.op = RTE_EVENT_OP_NEW, 450 .ev.queue_id = 0, 451 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 452 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 453 .ev.event_type = RTE_EVENT_TYPE_TIMER, 454 .state = RTE_EVENT_TIMER_NOT_ARMED, 455 .timeout_ticks = CALC_TICKS(timeout_tcks), 456 }; 457 458 for (i = 0; i < timers; i++) { 459 460 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 461 (void **)&ev_tim), 462 "mempool alloc failed"); 463 *ev_tim = tim; 464 ev_tim->ev.event_ptr = ev_tim; 465 466 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 467 1), 1, "Failed to arm timer %d", 468 rte_errno); 469 } 470 471 return TEST_SUCCESS; 472 } 473 474 static inline int 475 _wait_timer_triggers(uint64_t wait_sec, uint64_t arm_count, 476 uint64_t cancel_count) 477 { 478 uint8_t valid_event; 479 uint64_t events = 0; 480 uint64_t wait_start, max_wait; 481 struct rte_event ev; 482 483 max_wait = rte_get_timer_hz() * wait_sec; 484 wait_start = rte_get_timer_cycles(); 485 while (1) { 486 if (rte_get_timer_cycles() - wait_start > max_wait) { 487 if (events + cancel_count != arm_count) 488 TEST_ASSERT_SUCCESS(max_wait, 489 "Max time limit for timers exceeded."); 490 break; 491 } 492 493 valid_event = rte_event_dequeue_burst(evdev, 0, &ev, 1, 0); 494 if (!valid_event) 495 continue; 496 497 rte_mempool_put(eventdev_test_mempool, ev.event_ptr); 498 events++; 499 } 500 501 return TEST_SUCCESS; 502 } 503 504 static inline int 505 test_timer_arm(void) 506 { 507 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS), 508 "Failed to arm timers"); 509 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0), 510 "Timer triggered count doesn't match arm count"); 511 return TEST_SUCCESS; 512 } 513 514 static int 515 _arm_wrapper(void *arg) 516 { 517 RTE_SET_USED(arg); 518 519 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS), 520 "Failed to arm timers"); 521 522 return TEST_SUCCESS; 523 } 524 525 static inline int 526 test_timer_arm_multicore(void) 527 { 528 529 uint32_t lcore_1 = rte_get_next_lcore(-1, 1, 0); 530 uint32_t lcore_2 = rte_get_next_lcore(lcore_1, 1, 0); 531 532 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_1); 533 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_2); 534 535 rte_eal_mp_wait_lcore(); 536 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0), 537 "Timer triggered count doesn't match arm count"); 538 539 return TEST_SUCCESS; 540 } 541 542 #define MAX_BURST 16 543 static inline int 544 _arm_timers_burst(uint64_t timeout_tcks, uint64_t timers) 545 { 546 uint64_t i; 547 int j; 548 struct rte_event_timer *ev_tim[MAX_BURST]; 549 const struct rte_event_timer tim = { 550 .ev.op = RTE_EVENT_OP_NEW, 551 .ev.queue_id = 0, 552 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 553 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 554 .ev.event_type = RTE_EVENT_TYPE_TIMER, 555 .state = RTE_EVENT_TIMER_NOT_ARMED, 556 .timeout_ticks = CALC_TICKS(timeout_tcks), 557 }; 558 559 for (i = 0; i < timers / MAX_BURST; i++) { 560 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk( 561 eventdev_test_mempool, 562 (void **)ev_tim, MAX_BURST), 563 "mempool alloc failed"); 564 565 for (j = 0; j < MAX_BURST; j++) { 566 *ev_tim[j] = tim; 567 ev_tim[j]->ev.event_ptr = ev_tim[j]; 568 } 569 570 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev, 571 ev_tim, tim.timeout_ticks, MAX_BURST), 572 MAX_BURST, "Failed to arm timer %d", rte_errno); 573 } 574 575 return TEST_SUCCESS; 576 } 577 578 static inline int 579 test_timer_arm_burst(void) 580 { 581 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS), 582 "Failed to arm timers"); 583 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0), 584 "Timer triggered count doesn't match arm count"); 585 586 return TEST_SUCCESS; 587 } 588 589 static int 590 _arm_wrapper_burst(void *arg) 591 { 592 RTE_SET_USED(arg); 593 594 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS), 595 "Failed to arm timers"); 596 597 return TEST_SUCCESS; 598 } 599 600 static inline int 601 test_timer_arm_burst_multicore(void) 602 { 603 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore1); 604 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore2); 605 606 rte_eal_mp_wait_lcore(); 607 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0), 608 "Timer triggered count doesn't match arm count"); 609 610 return TEST_SUCCESS; 611 } 612 613 static inline int 614 test_timer_cancel(void) 615 { 616 uint64_t i; 617 struct rte_event_timer *ev_tim; 618 const struct rte_event_timer tim = { 619 .ev.op = RTE_EVENT_OP_NEW, 620 .ev.queue_id = 0, 621 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 622 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 623 .ev.event_type = RTE_EVENT_TYPE_TIMER, 624 .state = RTE_EVENT_TIMER_NOT_ARMED, 625 .timeout_ticks = CALC_TICKS(20), 626 }; 627 628 for (i = 0; i < MAX_TIMERS; i++) { 629 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 630 (void **)&ev_tim), 631 "mempool alloc failed"); 632 *ev_tim = tim; 633 ev_tim->ev.event_ptr = ev_tim; 634 635 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 636 1), 1, "Failed to arm timer %d", 637 rte_errno); 638 639 rte_delay_us(100 + (i % 5000)); 640 641 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, 642 &ev_tim, 1), 1, 643 "Failed to cancel event timer %d", rte_errno); 644 rte_mempool_put(eventdev_test_mempool, ev_tim); 645 } 646 647 648 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 649 MAX_TIMERS), 650 "Timer triggered count doesn't match arm, cancel count"); 651 652 return TEST_SUCCESS; 653 } 654 655 static int 656 _cancel_producer(uint64_t timeout_tcks, uint64_t timers) 657 { 658 uint64_t i; 659 struct rte_event_timer *ev_tim; 660 const struct rte_event_timer tim = { 661 .ev.op = RTE_EVENT_OP_NEW, 662 .ev.queue_id = 0, 663 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 664 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 665 .ev.event_type = RTE_EVENT_TYPE_TIMER, 666 .state = RTE_EVENT_TIMER_NOT_ARMED, 667 .timeout_ticks = CALC_TICKS(timeout_tcks), 668 }; 669 670 for (i = 0; i < timers; i++) { 671 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 672 (void **)&ev_tim), 673 "mempool alloc failed"); 674 675 *ev_tim = tim; 676 ev_tim->ev.event_ptr = ev_tim; 677 678 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 679 1), 1, "Failed to arm timer %d", 680 rte_errno); 681 682 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED, 683 "Failed to arm event timer"); 684 685 while (rte_ring_enqueue(timer_producer_ring, ev_tim) != 0) 686 ; 687 } 688 689 return TEST_SUCCESS; 690 } 691 692 static int 693 _cancel_producer_burst(uint64_t timeout_tcks, uint64_t timers) 694 { 695 696 uint64_t i; 697 int j, ret; 698 struct rte_event_timer *ev_tim[MAX_BURST]; 699 const struct rte_event_timer tim = { 700 .ev.op = RTE_EVENT_OP_NEW, 701 .ev.queue_id = 0, 702 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 703 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 704 .ev.event_type = RTE_EVENT_TYPE_TIMER, 705 .state = RTE_EVENT_TIMER_NOT_ARMED, 706 .timeout_ticks = CALC_TICKS(timeout_tcks), 707 }; 708 int arm_count = 0; 709 710 for (i = 0; i < timers / MAX_BURST; i++) { 711 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk( 712 eventdev_test_mempool, 713 (void **)ev_tim, MAX_BURST), 714 "mempool alloc failed"); 715 716 for (j = 0; j < MAX_BURST; j++) { 717 *ev_tim[j] = tim; 718 ev_tim[j]->ev.event_ptr = ev_tim[j]; 719 } 720 721 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev, 722 ev_tim, tim.timeout_ticks, MAX_BURST), 723 MAX_BURST, "Failed to arm timer %d", rte_errno); 724 725 for (j = 0; j < MAX_BURST; j++) 726 TEST_ASSERT_EQUAL(ev_tim[j]->state, 727 RTE_EVENT_TIMER_ARMED, 728 "Event timer not armed, state = %d", 729 ev_tim[j]->state); 730 731 ret = rte_ring_enqueue_bulk(timer_producer_ring, 732 (void **)ev_tim, MAX_BURST, NULL); 733 TEST_ASSERT_EQUAL(ret, MAX_BURST, 734 "Failed to enqueue event timers to ring"); 735 arm_count += ret; 736 } 737 738 TEST_ASSERT_EQUAL(arm_count, MAX_TIMERS, 739 "Failed to arm expected number of event timers"); 740 741 return TEST_SUCCESS; 742 } 743 744 static int 745 _cancel_producer_wrapper(void *args) 746 { 747 RTE_SET_USED(args); 748 749 return _cancel_producer(20, MAX_TIMERS); 750 } 751 752 static int 753 _cancel_producer_burst_wrapper(void *args) 754 { 755 RTE_SET_USED(args); 756 757 return _cancel_producer_burst(100, MAX_TIMERS); 758 } 759 760 static int 761 _cancel_thread(void *args) 762 { 763 RTE_SET_USED(args); 764 struct rte_event_timer *ev_tim = NULL; 765 uint64_t cancel_count = 0; 766 uint16_t ret; 767 768 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) { 769 if (rte_ring_dequeue(timer_producer_ring, (void **)&ev_tim)) 770 continue; 771 772 ret = rte_event_timer_cancel_burst(timdev, &ev_tim, 1); 773 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel timer"); 774 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim); 775 cancel_count++; 776 } 777 778 return TEST_SUCCESS; 779 } 780 781 static int 782 _cancel_burst_thread(void *args) 783 { 784 RTE_SET_USED(args); 785 786 int ret, i, n; 787 struct rte_event_timer *ev_tim[MAX_BURST]; 788 uint64_t cancel_count = 0; 789 uint64_t dequeue_count = 0; 790 791 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) { 792 n = rte_ring_dequeue_burst(timer_producer_ring, 793 (void **)ev_tim, MAX_BURST, NULL); 794 if (!n) 795 continue; 796 797 dequeue_count += n; 798 799 for (i = 0; i < n; i++) 800 TEST_ASSERT_EQUAL(ev_tim[i]->state, 801 RTE_EVENT_TIMER_ARMED, 802 "Event timer not armed, state = %d", 803 ev_tim[i]->state); 804 805 ret = rte_event_timer_cancel_burst(timdev, ev_tim, n); 806 TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of " 807 "event timers"); 808 rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim, 809 RTE_MIN(ret, MAX_BURST)); 810 811 cancel_count += ret; 812 } 813 814 TEST_ASSERT_EQUAL(cancel_count, MAX_TIMERS, 815 "Failed to cancel expected number of timers: " 816 "expected = %d, cancel_count = %"PRIu64", " 817 "dequeue_count = %"PRIu64"\n", MAX_TIMERS, 818 cancel_count, dequeue_count); 819 820 return TEST_SUCCESS; 821 } 822 823 static inline int 824 test_timer_cancel_multicore(void) 825 { 826 arm_done = 0; 827 timer_producer_ring = rte_ring_create("timer_cancel_queue", 828 MAX_TIMERS * 2, rte_socket_id(), 0); 829 TEST_ASSERT_NOT_NULL(timer_producer_ring, 830 "Unable to reserve memory for ring"); 831 832 rte_eal_remote_launch(_cancel_thread, NULL, test_lcore3); 833 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore1); 834 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore2); 835 836 rte_eal_wait_lcore(test_lcore1); 837 rte_eal_wait_lcore(test_lcore2); 838 arm_done = 1; 839 rte_eal_wait_lcore(test_lcore3); 840 rte_ring_free(timer_producer_ring); 841 842 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS * 2, 843 MAX_TIMERS * 2), 844 "Timer triggered count doesn't match arm count"); 845 846 return TEST_SUCCESS; 847 } 848 849 static inline int 850 test_timer_cancel_burst_multicore(void) 851 { 852 arm_done = 0; 853 timer_producer_ring = rte_ring_create("timer_cancel_queue", 854 MAX_TIMERS * 2, rte_socket_id(), 0); 855 TEST_ASSERT_NOT_NULL(timer_producer_ring, 856 "Unable to reserve memory for ring"); 857 858 rte_eal_remote_launch(_cancel_burst_thread, NULL, test_lcore2); 859 rte_eal_remote_launch(_cancel_producer_burst_wrapper, NULL, 860 test_lcore1); 861 862 rte_eal_wait_lcore(test_lcore1); 863 arm_done = 1; 864 rte_eal_wait_lcore(test_lcore2); 865 rte_ring_free(timer_producer_ring); 866 867 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 868 MAX_TIMERS), 869 "Timer triggered count doesn't match arm count"); 870 871 return TEST_SUCCESS; 872 } 873 874 static inline int 875 test_timer_cancel_random(void) 876 { 877 uint64_t i; 878 uint64_t events_canceled = 0; 879 struct rte_event_timer *ev_tim; 880 const struct rte_event_timer tim = { 881 .ev.op = RTE_EVENT_OP_NEW, 882 .ev.queue_id = 0, 883 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 884 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 885 .ev.event_type = RTE_EVENT_TYPE_TIMER, 886 .state = RTE_EVENT_TIMER_NOT_ARMED, 887 .timeout_ticks = CALC_TICKS(20), 888 }; 889 890 for (i = 0; i < MAX_TIMERS; i++) { 891 892 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 893 (void **)&ev_tim), 894 "mempool alloc failed"); 895 *ev_tim = tim; 896 ev_tim->ev.event_ptr = ev_tim; 897 898 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 899 1), 1, "Failed to arm timer %d", 900 rte_errno); 901 902 if (rte_rand() & 1) { 903 rte_delay_us(100 + (i % 5000)); 904 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst( 905 timdev, 906 &ev_tim, 1), 1, 907 "Failed to cancel event timer %d", rte_errno); 908 rte_mempool_put(eventdev_test_mempool, ev_tim); 909 events_canceled++; 910 } 911 } 912 913 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 914 events_canceled), 915 "Timer triggered count doesn't match arm, cancel count"); 916 917 return TEST_SUCCESS; 918 } 919 920 /* Check that the adapter can be created correctly */ 921 static int 922 adapter_create(void) 923 { 924 int adapter_id = 0; 925 struct rte_event_timer_adapter *adapter, *adapter2; 926 927 struct rte_event_timer_adapter_conf conf = { 928 .event_dev_id = evdev + 1, // invalid event dev id 929 .timer_adapter_id = adapter_id, 930 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK, 931 .timer_tick_ns = NSECPERSEC / 10, 932 .max_tmo_ns = 180 * NSECPERSEC, 933 .nb_timers = MAX_TIMERS, 934 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, 935 }; 936 uint32_t caps = 0; 937 938 /* Test invalid conf */ 939 adapter = rte_event_timer_adapter_create(&conf); 940 TEST_ASSERT_NULL(adapter, "Created adapter with invalid " 941 "event device id"); 942 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Incorrect errno value for " 943 "invalid event device id"); 944 945 /* Test valid conf */ 946 conf.event_dev_id = evdev; 947 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 948 "failed to get adapter capabilities"); 949 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) 950 adapter = rte_event_timer_adapter_create_ext(&conf, 951 test_port_conf_cb, 952 NULL); 953 else 954 adapter = rte_event_timer_adapter_create(&conf); 955 TEST_ASSERT_NOT_NULL(adapter, "Failed to create adapter with valid " 956 "configuration"); 957 958 /* Test existing id */ 959 adapter2 = rte_event_timer_adapter_create(&conf); 960 TEST_ASSERT_NULL(adapter2, "Created adapter with in-use id"); 961 TEST_ASSERT(rte_errno == EEXIST, "Incorrect errno value for existing " 962 "id"); 963 964 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapter), 965 "Failed to free adapter"); 966 967 rte_mempool_free(eventdev_test_mempool); 968 969 return TEST_SUCCESS; 970 } 971 972 973 /* Test that adapter can be freed correctly. */ 974 static int 975 adapter_free(void) 976 { 977 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 978 "Failed to stop adapter"); 979 980 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 981 "Failed to free valid adapter"); 982 983 /* Test free of already freed adapter */ 984 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 985 "Freed adapter that was already freed"); 986 987 /* Test free of null adapter */ 988 timdev = NULL; 989 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 990 "Freed null adapter"); 991 992 rte_mempool_free(eventdev_test_mempool); 993 994 return TEST_SUCCESS; 995 } 996 997 /* Test that adapter info can be retrieved and is correct. */ 998 static int 999 adapter_get_info(void) 1000 { 1001 struct rte_event_timer_adapter_info info; 1002 1003 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_get_info(timdev, &info), 1004 "Failed to get adapter info"); 1005 1006 if (using_services) 1007 TEST_ASSERT_EQUAL(info.event_dev_port_id, 1, 1008 "Expected port id = 1, got port id = %d", 1009 info.event_dev_port_id); 1010 1011 return TEST_SUCCESS; 1012 } 1013 1014 /* Test adapter lookup via adapter ID. */ 1015 static int 1016 adapter_lookup(void) 1017 { 1018 struct rte_event_timer_adapter *adapter; 1019 1020 adapter = rte_event_timer_adapter_lookup(TEST_ADAPTER_ID); 1021 TEST_ASSERT_NOT_NULL(adapter, "Failed to lookup adapter"); 1022 1023 return TEST_SUCCESS; 1024 } 1025 1026 static int 1027 adapter_start(void) 1028 { 1029 TEST_ASSERT_SUCCESS(_timdev_setup(180 * NSECPERSEC, 1030 NSECPERSEC / 10), 1031 "Failed to start adapter"); 1032 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), -EALREADY, 1033 "Timer adapter started without call to stop."); 1034 1035 return TEST_SUCCESS; 1036 } 1037 1038 /* Test that adapter stops correctly. */ 1039 static int 1040 adapter_stop(void) 1041 { 1042 struct rte_event_timer_adapter *l_adapter = NULL; 1043 1044 /* Test adapter stop */ 1045 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 1046 "Failed to stop event adapter"); 1047 1048 TEST_ASSERT_FAIL(rte_event_timer_adapter_stop(l_adapter), 1049 "Erroneously stopped null event adapter"); 1050 1051 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 1052 "Failed to free adapter"); 1053 1054 rte_mempool_free(eventdev_test_mempool); 1055 1056 return TEST_SUCCESS; 1057 } 1058 1059 /* Test increment and reset of ev_enq_count stat */ 1060 static int 1061 stat_inc_reset_ev_enq(void) 1062 { 1063 int ret, i, n; 1064 int num_evtims = MAX_TIMERS; 1065 struct rte_event_timer *evtims[num_evtims]; 1066 struct rte_event evs[BATCH_SIZE]; 1067 struct rte_event_timer_adapter_stats stats; 1068 const struct rte_event_timer init_tim = { 1069 .ev.op = RTE_EVENT_OP_NEW, 1070 .ev.queue_id = TEST_QUEUE_ID, 1071 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1072 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1073 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1074 .state = RTE_EVENT_TIMER_NOT_ARMED, 1075 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1076 }; 1077 1078 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1079 num_evtims); 1080 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1081 ret); 1082 1083 for (i = 0; i < num_evtims; i++) { 1084 *evtims[i] = init_tim; 1085 evtims[i]->ev.event_ptr = evtims[i]; 1086 } 1087 1088 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1089 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1090 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, "Stats not clear at " 1091 "startup"); 1092 1093 /* Test with the max value for the adapter */ 1094 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims); 1095 TEST_ASSERT_EQUAL(ret, num_evtims, 1096 "Failed to arm all event timers: attempted = %d, " 1097 "succeeded = %d, rte_errno = %s", 1098 num_evtims, ret, rte_strerror(rte_errno)); 1099 1100 rte_delay_ms(1000); 1101 1102 #define MAX_TRIES num_evtims 1103 int sum = 0; 1104 int tries = 0; 1105 bool done = false; 1106 while (!done) { 1107 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1108 RTE_DIM(evs), 10); 1109 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1110 done = true; 1111 1112 rte_delay_ms(10); 1113 } 1114 1115 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1116 "got %d", num_evtims, sum); 1117 1118 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1119 1120 rte_delay_ms(100); 1121 1122 /* Make sure the eventdev is still empty */ 1123 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1124 10); 1125 1126 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1127 "events from event device"); 1128 1129 /* Check stats again */ 1130 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1131 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1132 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, num_evtims, 1133 "Expected enqueue stat = %d; got %d", num_evtims, 1134 (int)stats.ev_enq_count); 1135 1136 /* Reset and check again */ 1137 ret = rte_event_timer_adapter_stats_reset(timdev); 1138 TEST_ASSERT_EQUAL(ret, 0, "Failed to reset stats"); 1139 1140 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1141 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1142 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, 1143 "Expected enqueue stat = %d; got %d", 0, 1144 (int)stats.ev_enq_count); 1145 1146 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1147 num_evtims); 1148 1149 return TEST_SUCCESS; 1150 } 1151 1152 /* Test various cases in arming timers */ 1153 static int 1154 event_timer_arm(void) 1155 { 1156 uint16_t n; 1157 int ret; 1158 struct rte_event_timer_adapter *adapter = timdev; 1159 struct rte_event_timer *evtim = NULL; 1160 struct rte_event evs[BATCH_SIZE]; 1161 const struct rte_event_timer init_tim = { 1162 .ev.op = RTE_EVENT_OP_NEW, 1163 .ev.queue_id = TEST_QUEUE_ID, 1164 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1165 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1166 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1167 .state = RTE_EVENT_TIMER_NOT_ARMED, 1168 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1169 }; 1170 1171 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1172 if (evtim == NULL) { 1173 /* Failed to get an event timer object */ 1174 return TEST_FAILED; 1175 } 1176 1177 /* Set up a timer */ 1178 *evtim = init_tim; 1179 evtim->ev.event_ptr = evtim; 1180 1181 /* Test single timer arm succeeds */ 1182 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1183 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1184 rte_strerror(rte_errno)); 1185 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event timer " 1186 "in incorrect state"); 1187 1188 /* Test arm of armed timer fails */ 1189 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1190 TEST_ASSERT_EQUAL(ret, 0, "expected return value from " 1191 "rte_event_timer_arm_burst: 0, got: %d", ret); 1192 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1193 "after arming already armed timer"); 1194 1195 /* Let timer expire */ 1196 rte_delay_ms(1000); 1197 1198 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1199 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1200 "events from event device"); 1201 1202 rte_mempool_put(eventdev_test_mempool, evtim); 1203 1204 return TEST_SUCCESS; 1205 } 1206 1207 /* This test checks that repeated references to the same event timer in the 1208 * arm request work as expected; only the first one through should succeed. 1209 */ 1210 static int 1211 event_timer_arm_double(void) 1212 { 1213 uint16_t n; 1214 int ret; 1215 struct rte_event_timer_adapter *adapter = timdev; 1216 struct rte_event_timer *evtim = NULL; 1217 struct rte_event evs[BATCH_SIZE]; 1218 const struct rte_event_timer init_tim = { 1219 .ev.op = RTE_EVENT_OP_NEW, 1220 .ev.queue_id = TEST_QUEUE_ID, 1221 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1222 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1223 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1224 .state = RTE_EVENT_TIMER_NOT_ARMED, 1225 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1226 }; 1227 1228 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1229 if (evtim == NULL) { 1230 /* Failed to get an event timer object */ 1231 return TEST_FAILED; 1232 } 1233 1234 /* Set up a timer */ 1235 *evtim = init_tim; 1236 evtim->ev.event_ptr = evtim; 1237 1238 struct rte_event_timer *evtim_arr[] = {evtim, evtim}; 1239 ret = rte_event_timer_arm_burst(adapter, evtim_arr, RTE_DIM(evtim_arr)); 1240 TEST_ASSERT_EQUAL(ret, 1, "Unexpected return value from " 1241 "rte_event_timer_arm_burst"); 1242 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1243 "after double-arm"); 1244 1245 /* Let timer expire */ 1246 rte_delay_ms(600); 1247 1248 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1249 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number of expiry events - " 1250 "expected: 1, actual: %d", n); 1251 1252 rte_mempool_put(eventdev_test_mempool, evtim); 1253 1254 return TEST_SUCCESS; 1255 } 1256 1257 /* Test the timer expiry event is generated at the expected time. */ 1258 static int 1259 event_timer_arm_expiry(void) 1260 { 1261 uint16_t n; 1262 int ret; 1263 struct rte_event_timer_adapter *adapter = timdev; 1264 struct rte_event_timer *evtim = NULL; 1265 struct rte_event_timer *evtim2 = NULL; 1266 struct rte_event evs[BATCH_SIZE]; 1267 const struct rte_event_timer init_tim = { 1268 .ev.op = RTE_EVENT_OP_NEW, 1269 .ev.queue_id = TEST_QUEUE_ID, 1270 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1271 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1272 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1273 .state = RTE_EVENT_TIMER_NOT_ARMED, 1274 }; 1275 1276 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1277 if (evtim == NULL) { 1278 /* Failed to get an event timer object */ 1279 return TEST_FAILED; 1280 } 1281 1282 /* Set up an event timer */ 1283 *evtim = init_tim; 1284 evtim->timeout_ticks = CALC_TICKS(30), // expire in 3 secs 1285 evtim->ev.event_ptr = evtim; 1286 1287 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1288 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s", 1289 rte_strerror(rte_errno)); 1290 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event " 1291 "timer in incorrect state"); 1292 1293 rte_delay_ms(2999); 1294 1295 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1296 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event"); 1297 1298 /* Delay 100 ms to account for the adapter tick window - should let us 1299 * dequeue one event 1300 */ 1301 rte_delay_ms(100); 1302 1303 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1304 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number (%d) of timer " 1305 "expiry events", n); 1306 TEST_ASSERT_EQUAL(evs[0].event_type, RTE_EVENT_TYPE_TIMER, 1307 "Dequeued unexpected type of event"); 1308 1309 /* Check that we recover the original event timer and then free it */ 1310 evtim2 = evs[0].event_ptr; 1311 TEST_ASSERT_EQUAL(evtim, evtim2, 1312 "Failed to recover pointer to original event timer"); 1313 rte_mempool_put(eventdev_test_mempool, evtim2); 1314 1315 return TEST_SUCCESS; 1316 } 1317 1318 /* Check that rearming a timer works as expected. */ 1319 static int 1320 event_timer_arm_rearm(void) 1321 { 1322 uint16_t n; 1323 int ret; 1324 struct rte_event_timer *evtim = NULL; 1325 struct rte_event_timer *evtim2 = NULL; 1326 struct rte_event evs[BATCH_SIZE]; 1327 const struct rte_event_timer init_tim = { 1328 .ev.op = RTE_EVENT_OP_NEW, 1329 .ev.queue_id = TEST_QUEUE_ID, 1330 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1331 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1332 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1333 .state = RTE_EVENT_TIMER_NOT_ARMED, 1334 }; 1335 1336 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1337 if (evtim == NULL) { 1338 /* Failed to get an event timer object */ 1339 return TEST_FAILED; 1340 } 1341 1342 /* Set up a timer */ 1343 *evtim = init_tim; 1344 evtim->timeout_ticks = CALC_TICKS(1); // expire in 0.1 sec 1345 evtim->ev.event_ptr = evtim; 1346 1347 /* Arm it */ 1348 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1349 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1350 rte_strerror(rte_errno)); 1351 1352 /* Add 100ms to account for the adapter tick window */ 1353 rte_delay_ms(100 + 100); 1354 1355 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1356 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1357 "events from event device"); 1358 1359 /* Recover the timer through the event that was dequeued. */ 1360 evtim2 = evs[0].event_ptr; 1361 TEST_ASSERT_EQUAL(evtim, evtim2, 1362 "Failed to recover pointer to original event timer"); 1363 1364 /* Need to reset state in case implementation can't do it */ 1365 evtim2->state = RTE_EVENT_TIMER_NOT_ARMED; 1366 1367 /* Rearm it */ 1368 ret = rte_event_timer_arm_burst(timdev, &evtim2, 1); 1369 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1370 rte_strerror(rte_errno)); 1371 1372 /* Add 100ms to account for the adapter tick window */ 1373 rte_delay_ms(100 + 100); 1374 1375 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1376 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1377 "events from event device"); 1378 1379 /* Free it */ 1380 evtim2 = evs[0].event_ptr; 1381 TEST_ASSERT_EQUAL(evtim, evtim2, 1382 "Failed to recover pointer to original event timer"); 1383 rte_mempool_put(eventdev_test_mempool, evtim2); 1384 1385 return TEST_SUCCESS; 1386 } 1387 1388 /* Check that the adapter handles the max specified number of timers as 1389 * expected. 1390 */ 1391 static int 1392 event_timer_arm_max(void) 1393 { 1394 int ret, i, n; 1395 int num_evtims = MAX_TIMERS; 1396 struct rte_event_timer *evtims[num_evtims]; 1397 struct rte_event evs[BATCH_SIZE]; 1398 const struct rte_event_timer init_tim = { 1399 .ev.op = RTE_EVENT_OP_NEW, 1400 .ev.queue_id = TEST_QUEUE_ID, 1401 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1402 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1403 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1404 .state = RTE_EVENT_TIMER_NOT_ARMED, 1405 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1406 }; 1407 1408 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1409 num_evtims); 1410 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1411 ret); 1412 1413 for (i = 0; i < num_evtims; i++) { 1414 *evtims[i] = init_tim; 1415 evtims[i]->ev.event_ptr = evtims[i]; 1416 } 1417 1418 /* Test with the max value for the adapter */ 1419 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims); 1420 TEST_ASSERT_EQUAL(ret, num_evtims, 1421 "Failed to arm all event timers: attempted = %d, " 1422 "succeeded = %d, rte_errno = %s", 1423 num_evtims, ret, rte_strerror(rte_errno)); 1424 1425 rte_delay_ms(1000); 1426 1427 #define MAX_TRIES num_evtims 1428 int sum = 0; 1429 int tries = 0; 1430 bool done = false; 1431 while (!done) { 1432 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1433 RTE_DIM(evs), 10); 1434 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1435 done = true; 1436 1437 rte_delay_ms(10); 1438 } 1439 1440 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1441 "got %d", num_evtims, sum); 1442 1443 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1444 1445 rte_delay_ms(100); 1446 1447 /* Make sure the eventdev is still empty */ 1448 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1449 10); 1450 1451 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1452 "events from event device"); 1453 1454 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1455 num_evtims); 1456 1457 return TEST_SUCCESS; 1458 } 1459 1460 /* Check that creating an event timer with incorrect event sched type fails. */ 1461 static int 1462 event_timer_arm_invalid_sched_type(void) 1463 { 1464 int ret; 1465 struct rte_event_timer *evtim = NULL; 1466 const struct rte_event_timer init_tim = { 1467 .ev.op = RTE_EVENT_OP_NEW, 1468 .ev.queue_id = TEST_QUEUE_ID, 1469 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1470 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1471 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1472 .state = RTE_EVENT_TIMER_NOT_ARMED, 1473 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1474 }; 1475 1476 if (!using_services) 1477 return -ENOTSUP; 1478 1479 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1480 if (evtim == NULL) { 1481 /* Failed to get an event timer object */ 1482 return TEST_FAILED; 1483 } 1484 1485 *evtim = init_tim; 1486 evtim->ev.event_ptr = evtim; 1487 evtim->ev.sched_type = RTE_SCHED_TYPE_PARALLEL; // bad sched type 1488 1489 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1490 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1491 "sched type, but didn't"); 1492 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1493 " arm fail with invalid queue"); 1494 1495 rte_mempool_put(eventdev_test_mempool, &evtim); 1496 1497 return TEST_SUCCESS; 1498 } 1499 1500 /* Check that creating an event timer with a timeout value that is too small or 1501 * too big fails. 1502 */ 1503 static int 1504 event_timer_arm_invalid_timeout(void) 1505 { 1506 int ret; 1507 struct rte_event_timer *evtim = NULL; 1508 const struct rte_event_timer init_tim = { 1509 .ev.op = RTE_EVENT_OP_NEW, 1510 .ev.queue_id = TEST_QUEUE_ID, 1511 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1512 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1513 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1514 .state = RTE_EVENT_TIMER_NOT_ARMED, 1515 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1516 }; 1517 1518 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1519 if (evtim == NULL) { 1520 /* Failed to get an event timer object */ 1521 return TEST_FAILED; 1522 } 1523 1524 *evtim = init_tim; 1525 evtim->ev.event_ptr = evtim; 1526 evtim->timeout_ticks = 0; // timeout too small 1527 1528 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1529 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1530 "timeout, but didn't"); 1531 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1532 " arm fail with invalid timeout"); 1533 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOEARLY, 1534 "Unexpected event timer state"); 1535 1536 *evtim = init_tim; 1537 evtim->ev.event_ptr = evtim; 1538 evtim->timeout_ticks = CALC_TICKS(1801); // timeout too big 1539 1540 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1541 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1542 "timeout, but didn't"); 1543 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1544 " arm fail with invalid timeout"); 1545 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOLATE, 1546 "Unexpected event timer state"); 1547 1548 rte_mempool_put(eventdev_test_mempool, evtim); 1549 1550 return TEST_SUCCESS; 1551 } 1552 1553 static int 1554 event_timer_cancel(void) 1555 { 1556 uint16_t n; 1557 int ret; 1558 struct rte_event_timer_adapter *adapter = timdev; 1559 struct rte_event_timer *evtim = NULL; 1560 struct rte_event evs[BATCH_SIZE]; 1561 const struct rte_event_timer init_tim = { 1562 .ev.op = RTE_EVENT_OP_NEW, 1563 .ev.queue_id = TEST_QUEUE_ID, 1564 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1565 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1566 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1567 .state = RTE_EVENT_TIMER_NOT_ARMED, 1568 }; 1569 1570 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1571 if (evtim == NULL) { 1572 /* Failed to get an event timer object */ 1573 return TEST_FAILED; 1574 } 1575 1576 /* Check that cancelling an uninited timer fails */ 1577 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1578 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling " 1579 "uninited timer"); 1580 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1581 "cancelling uninited timer"); 1582 1583 /* Set up a timer */ 1584 *evtim = init_tim; 1585 evtim->ev.event_ptr = evtim; 1586 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1587 1588 /* Check that cancelling an inited but unarmed timer fails */ 1589 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1590 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling " 1591 "unarmed timer"); 1592 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1593 "cancelling unarmed timer"); 1594 1595 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1596 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1597 rte_strerror(rte_errno)); 1598 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, 1599 "evtim in incorrect state"); 1600 1601 /* Delay 1 sec */ 1602 rte_delay_ms(1000); 1603 1604 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1605 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel event_timer: %s\n", 1606 rte_strerror(rte_errno)); 1607 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_CANCELED, 1608 "evtim in incorrect state"); 1609 1610 rte_delay_ms(3000); 1611 1612 /* Make sure that no expiry event was generated */ 1613 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1614 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n"); 1615 1616 rte_mempool_put(eventdev_test_mempool, evtim); 1617 1618 return TEST_SUCCESS; 1619 } 1620 1621 static int 1622 event_timer_cancel_double(void) 1623 { 1624 uint16_t n; 1625 int ret; 1626 struct rte_event_timer_adapter *adapter = timdev; 1627 struct rte_event_timer *evtim = NULL; 1628 struct rte_event evs[BATCH_SIZE]; 1629 const struct rte_event_timer init_tim = { 1630 .ev.op = RTE_EVENT_OP_NEW, 1631 .ev.queue_id = TEST_QUEUE_ID, 1632 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1633 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1634 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1635 .state = RTE_EVENT_TIMER_NOT_ARMED, 1636 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1637 }; 1638 1639 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1640 if (evtim == NULL) { 1641 /* Failed to get an event timer object */ 1642 return TEST_FAILED; 1643 } 1644 1645 /* Set up a timer */ 1646 *evtim = init_tim; 1647 evtim->ev.event_ptr = evtim; 1648 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1649 1650 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1651 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1652 rte_strerror(rte_errno)); 1653 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, 1654 "timer in unexpected state"); 1655 1656 /* Now, test that referencing the same timer twice in the same call 1657 * fails 1658 */ 1659 struct rte_event_timer *evtim_arr[] = {evtim, evtim}; 1660 ret = rte_event_timer_cancel_burst(adapter, evtim_arr, 1661 RTE_DIM(evtim_arr)); 1662 1663 /* Two requests to cancel same timer, only one should succeed */ 1664 TEST_ASSERT_EQUAL(ret, 1, "Succeeded unexpectedly in canceling timer " 1665 "twice"); 1666 1667 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1668 "after double-cancel: rte_errno = %d", rte_errno); 1669 1670 rte_delay_ms(3000); 1671 1672 /* Still make sure that no expiry event was generated */ 1673 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1674 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n"); 1675 1676 rte_mempool_put(eventdev_test_mempool, evtim); 1677 1678 return TEST_SUCCESS; 1679 } 1680 1681 /* Check that event timer adapter tick resolution works as expected by testing 1682 * the number of adapter ticks that occur within a particular time interval. 1683 */ 1684 static int 1685 adapter_tick_resolution(void) 1686 { 1687 struct rte_event_timer_adapter_stats stats; 1688 uint64_t adapter_tick_count; 1689 1690 /* Only run this test in the software driver case */ 1691 if (!using_services) 1692 return -ENOTSUP; 1693 1694 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_reset(timdev), 1695 "Failed to reset stats"); 1696 1697 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev, 1698 &stats), "Failed to get adapter stats"); 1699 TEST_ASSERT_EQUAL(stats.adapter_tick_count, 0, "Adapter tick count " 1700 "not zeroed out"); 1701 1702 /* Delay 1 second; should let at least 10 ticks occur with the default 1703 * adapter configuration used by this test. 1704 */ 1705 rte_delay_ms(1000); 1706 1707 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev, 1708 &stats), "Failed to get adapter stats"); 1709 1710 adapter_tick_count = stats.adapter_tick_count; 1711 TEST_ASSERT(adapter_tick_count >= 10 && adapter_tick_count <= 12, 1712 "Expected 10-12 adapter ticks, got %"PRIu64"\n", 1713 adapter_tick_count); 1714 1715 return TEST_SUCCESS; 1716 } 1717 1718 static int 1719 adapter_create_max(void) 1720 { 1721 int i; 1722 uint32_t svc_start_count, svc_end_count; 1723 struct rte_event_timer_adapter *adapters[ 1724 RTE_EVENT_TIMER_ADAPTER_NUM_MAX + 1]; 1725 1726 struct rte_event_timer_adapter_conf conf = { 1727 .event_dev_id = evdev, 1728 // timer_adapter_id set in loop 1729 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK, 1730 .timer_tick_ns = NSECPERSEC / 10, 1731 .max_tmo_ns = 180 * NSECPERSEC, 1732 .nb_timers = MAX_TIMERS, 1733 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, 1734 }; 1735 1736 if (!using_services) 1737 return -ENOTSUP; 1738 1739 svc_start_count = rte_service_get_count(); 1740 1741 /* This test expects that there are sufficient service IDs available 1742 * to be allocated. I.e., RTE_EVENT_TIMER_ADAPTER_NUM_MAX may need to 1743 * be less than RTE_SERVICE_NUM_MAX if anything else uses a service 1744 * (the SW event device, for example). 1745 */ 1746 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) { 1747 conf.timer_adapter_id = i; 1748 adapters[i] = rte_event_timer_adapter_create_ext(&conf, 1749 test_port_conf_cb, NULL); 1750 TEST_ASSERT_NOT_NULL(adapters[i], "Failed to create adapter " 1751 "%d", i); 1752 } 1753 1754 conf.timer_adapter_id = i; 1755 adapters[i] = rte_event_timer_adapter_create(&conf); 1756 TEST_ASSERT_NULL(adapters[i], "Created too many adapters"); 1757 1758 /* Check that at least RTE_EVENT_TIMER_ADAPTER_NUM_MAX services 1759 * have been created 1760 */ 1761 svc_end_count = rte_service_get_count(); 1762 TEST_ASSERT_EQUAL(svc_end_count - svc_start_count, 1763 RTE_EVENT_TIMER_ADAPTER_NUM_MAX, 1764 "Failed to create expected number of services"); 1765 1766 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) 1767 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapters[i]), 1768 "Failed to free adapter %d", i); 1769 1770 /* Check that service count is back to where it was at start */ 1771 svc_end_count = rte_service_get_count(); 1772 TEST_ASSERT_EQUAL(svc_start_count, svc_end_count, "Failed to release " 1773 "correct number of services"); 1774 1775 return TEST_SUCCESS; 1776 } 1777 1778 static struct unit_test_suite event_timer_adptr_functional_testsuite = { 1779 .suite_name = "event timer functional test suite", 1780 .setup = testsuite_setup, 1781 .teardown = testsuite_teardown, 1782 .unit_test_cases = { 1783 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1784 test_timer_state), 1785 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1786 test_timer_arm), 1787 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1788 test_timer_arm_burst), 1789 TEST_CASE_ST(timdev_setup_sec, timdev_teardown, 1790 test_timer_cancel), 1791 TEST_CASE_ST(timdev_setup_sec, timdev_teardown, 1792 test_timer_cancel_random), 1793 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown, 1794 test_timer_arm_multicore), 1795 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown, 1796 test_timer_arm_burst_multicore), 1797 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown, 1798 test_timer_cancel_multicore), 1799 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown, 1800 test_timer_cancel_burst_multicore), 1801 TEST_CASE(adapter_create), 1802 TEST_CASE_ST(timdev_setup_msec, NULL, adapter_free), 1803 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1804 adapter_get_info), 1805 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1806 adapter_lookup), 1807 TEST_CASE_ST(NULL, timdev_teardown, 1808 adapter_start), 1809 TEST_CASE_ST(timdev_setup_msec, NULL, 1810 adapter_stop), 1811 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1812 stat_inc_reset_ev_enq), 1813 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1814 event_timer_arm), 1815 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1816 event_timer_arm_double), 1817 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1818 event_timer_arm_expiry), 1819 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1820 event_timer_arm_rearm), 1821 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1822 event_timer_arm_max), 1823 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1824 event_timer_arm_invalid_sched_type), 1825 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1826 event_timer_arm_invalid_timeout), 1827 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1828 event_timer_cancel), 1829 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1830 event_timer_cancel_double), 1831 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1832 adapter_tick_resolution), 1833 TEST_CASE(adapter_create_max), 1834 TEST_CASES_END() /**< NULL terminate unit test array */ 1835 } 1836 }; 1837 1838 static int 1839 test_event_timer_adapter_func(void) 1840 { 1841 return unit_test_suite_runner(&event_timer_adptr_functional_testsuite); 1842 } 1843 1844 REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func); 1845