1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2017 Cavium, Inc 3 * Copyright(c) 2017-2018 Intel Corporation. 4 */ 5 6 #include "test.h" 7 8 #include <math.h> 9 10 #include <rte_common.h> 11 #include <rte_cycles.h> 12 #include <rte_debug.h> 13 #include <rte_eal.h> 14 #include <rte_ethdev.h> 15 16 #ifdef RTE_EXEC_ENV_WINDOWS 17 static int 18 test_event_timer_adapter_func(void) 19 { 20 printf("event_timer_adapter not supported on Windows, skipping test\n"); 21 return TEST_SKIPPED; 22 } 23 24 #else 25 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> 35 #include <stdbool.h> 36 37 /* 4K timers corresponds to sw evdev max inflight events */ 38 #define MAX_TIMERS (4 * 1024) 39 #define BKT_TCK_NSEC 40 41 #define NSECPERSEC 1E9 42 #define BATCH_SIZE 16 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 48 49 /* Handle log statements in same manner as test macros */ 50 #define LOG_DBG(...) RTE_LOG(DEBUG, EAL, __VA_ARGS__) 51 52 static int evdev; 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; 59 60 #define CALC_TICKS(tks) \ 61 ceil((double)(tks * global_bkt_tck_ns) / global_info_bkt_tck_ns) 62 63 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; 70 71 static inline void 72 devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf, 73 struct rte_event_dev_info *info) 74 { 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 = 87 info->max_num_events; 88 } 89 90 static inline int 91 eventdev_setup(void) 92 { 93 int ret; 94 struct rte_event_dev_config dev_conf; 95 struct rte_event_dev_info info; 96 uint32_t service_id; 97 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); 104 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"); 108 109 ret = rte_event_queue_setup(evdev, 0, NULL); 110 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue=%d", 0); 111 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); 117 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( 123 sw_evdev_slcore), 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( 129 service_id, 1), 130 "Failed to start evdev service"); 131 } 132 133 ret = rte_event_dev_start(evdev); 134 TEST_ASSERT_SUCCESS(ret, "Failed to start device"); 135 136 return TEST_SUCCESS; 137 } 138 139 static int 140 testsuite_setup(void) 141 { 142 /* Some of the multithreaded tests require 3 other lcores to run */ 143 unsigned int required_lcore_count = 4; 144 uint32_t service_id; 145 146 /* To make it easier to map services later if needed, just reset 147 * service core state. 148 */ 149 (void) rte_service_lcore_reset_all(); 150 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 154 * event_sw. 155 */ 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"); 161 } 162 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 166 * service cores. 167 */ 168 required_lcore_count += 2; 169 using_services = true; 170 } 171 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); 175 return TEST_SKIPPED; 176 } 177 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); 185 } 186 187 return eventdev_setup(); 188 } 189 190 static void 191 testsuite_teardown(void) 192 { 193 rte_event_dev_stop(evdev); 194 rte_event_dev_close(evdev); 195 } 196 197 static int 198 setup_adapter_service(struct rte_event_timer_adapter *adptr) 199 { 200 uint32_t adapter_service_id; 201 int ret; 202 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"); 214 215 /* map services to it */ 216 TEST_ASSERT_SUCCESS(rte_service_map_lcore_set(adapter_service_id, 217 sw_adptr_slcore, 1), 218 "Failed to map adapter service"); 219 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"); 223 224 return TEST_SUCCESS; 225 } 226 227 static int 228 test_port_conf_cb(uint16_t id, uint8_t event_dev_id, uint8_t *event_port_id, 229 void *conf_arg) 230 { 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}; 234 uint32_t started; 235 static int port_allocated; 236 static uint8_t port_id; 237 int ret; 238 239 if (port_allocated) { 240 *event_port_id = port_id; 241 return 0; 242 } 243 244 RTE_SET_USED(id); 245 246 ret = rte_event_dev_attr_get(event_dev_id, RTE_EVENT_DEV_ATTR_STARTED, 247 &started); 248 if (ret < 0) 249 return ret; 250 251 if (started) 252 rte_event_dev_stop(event_dev_id); 253 254 ret = rte_event_dev_info_get(evdev, &info); 255 if (ret < 0) 256 return ret; 257 258 devconf_set_default_sane_values(&dev_conf, &info); 259 260 port_id = dev_conf.nb_event_ports; 261 dev_conf.nb_event_ports++; 262 263 ret = rte_event_dev_configure(event_dev_id, &dev_conf); 264 if (ret < 0) { 265 if (started) 266 rte_event_dev_start(event_dev_id); 267 return ret; 268 } 269 270 if (conf_arg != NULL) 271 port_conf = conf_arg; 272 else { 273 port_conf = &def_port_conf; 274 ret = rte_event_port_default_conf_get(event_dev_id, port_id, 275 port_conf); 276 if (ret < 0) 277 return ret; 278 } 279 280 ret = rte_event_port_setup(event_dev_id, port_id, port_conf); 281 if (ret < 0) 282 return ret; 283 284 *event_port_id = port_id; 285 286 if (started) 287 rte_event_dev_start(event_dev_id); 288 289 /* Reuse this port number next time this is called */ 290 port_allocated = 1; 291 292 return 0; 293 } 294 295 static int 296 _timdev_setup(uint64_t max_tmo_ns, uint64_t bkt_tck_ns, uint64_t flags) 297 { 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, 305 .flags = flags, 306 }; 307 uint32_t caps = 0; 308 const char *pool_name = "timdev_test_pool"; 309 310 global_bkt_tck_ns = bkt_tck_ns; 311 312 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 313 "failed to get adapter capabilities"); 314 315 if (flags & RTE_EVENT_TIMER_ADAPTER_F_PERIODIC && 316 !(caps & RTE_EVENT_TIMER_ADAPTER_CAP_PERIODIC)) 317 return -ENOTSUP; 318 319 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) { 320 timdev = rte_event_timer_adapter_create_ext(&config, 321 test_port_conf_cb, 322 NULL); 323 setup_adapter_service(timdev); 324 using_services = true; 325 } else 326 timdev = rte_event_timer_adapter_create(&config); 327 328 TEST_ASSERT_NOT_NULL(timdev, 329 "failed to create event timer ring"); 330 331 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), 0, 332 "failed to Start event timer adapter"); 333 334 /* Create event timer mempool */ 335 eventdev_test_mempool = rte_mempool_create(pool_name, 336 MAX_TIMERS * 2, 337 sizeof(struct rte_event_timer), /* element size*/ 338 0, /* cache size*/ 339 0, NULL, NULL, NULL, NULL, 340 rte_socket_id(), 0); 341 if (!eventdev_test_mempool) { 342 printf("ERROR creating mempool\n"); 343 return TEST_FAILED; 344 } 345 346 rte_event_timer_adapter_get_info(timdev, &info); 347 348 global_info_bkt_tck_ns = info.min_resolution_ns; 349 350 return TEST_SUCCESS; 351 } 352 353 static int 354 timdev_setup_usec(void) 355 { 356 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 357 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); 363 } 364 365 static int 366 timdev_setup_usec_multicore(void) 367 { 368 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 369 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); 375 } 376 377 static int 378 timdev_setup_msec(void) 379 { 380 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 381 382 /* Max timeout is 3 mins, and bucket interval is 100 ms */ 383 return _timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10, flags); 384 } 385 386 static int 387 timdev_setup_msec_periodic(void) 388 { 389 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES | 390 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC; 391 392 /* Periodic mode with 100 ms resolution */ 393 return _timdev_setup(0, NSECPERSEC / 10, flags); 394 } 395 396 static int 397 timdev_setup_sec(void) 398 { 399 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 400 401 /* Max timeout is 100sec and bucket interval is 1sec */ 402 return _timdev_setup(1E11, 1E9, flags); 403 } 404 405 static int 406 timdev_setup_sec_periodic(void) 407 { 408 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES | 409 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC; 410 411 /* Periodic mode with 1 sec resolution */ 412 return _timdev_setup(0, NSECPERSEC, flags); 413 } 414 415 static int 416 timdev_setup_sec_multicore(void) 417 { 418 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 419 420 /* Max timeout is 100sec and bucket interval is 1sec */ 421 return _timdev_setup(1E11, 1E9, flags); 422 } 423 424 static void 425 timdev_teardown(void) 426 { 427 rte_event_timer_adapter_stop(timdev); 428 rte_event_timer_adapter_free(timdev); 429 430 rte_mempool_free(eventdev_test_mempool); 431 } 432 433 static inline int 434 test_timer_state(void) 435 { 436 struct rte_event_timer *ev_tim; 437 struct rte_event ev; 438 const struct rte_event_timer tim = { 439 .ev.op = RTE_EVENT_OP_NEW, 440 .ev.queue_id = 0, 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, 445 }; 446 447 448 rte_mempool_get(eventdev_test_mempool, (void **)&ev_tim); 449 *ev_tim = tim; 450 ev_tim->ev.event_ptr = ev_tim; 451 ev_tim->timeout_ticks = CALC_TICKS(120); 452 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); 458 459 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED; 460 ev_tim->timeout_ticks = CALC_TICKS(10); 461 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); 467 468 if (!using_services) 469 rte_delay_us(20); 470 else 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."); 474 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); 484 485 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim); 486 487 return TEST_SUCCESS; 488 } 489 490 static inline int 491 _arm_timers(uint64_t timeout_tcks, uint64_t timers) 492 { 493 uint64_t i; 494 struct rte_event_timer *ev_tim; 495 const struct rte_event_timer tim = { 496 .ev.op = RTE_EVENT_OP_NEW, 497 .ev.queue_id = 0, 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), 503 }; 504 505 for (i = 0; i < timers; i++) { 506 507 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 508 (void **)&ev_tim), 509 "mempool alloc failed"); 510 *ev_tim = tim; 511 ev_tim->ev.event_ptr = ev_tim; 512 513 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 514 1), 1, "Failed to arm timer %d", 515 rte_errno); 516 } 517 518 return TEST_SUCCESS; 519 } 520 521 static inline int 522 _wait_timer_triggers(uint64_t wait_sec, uint64_t arm_count, 523 uint64_t cancel_count) 524 { 525 uint8_t valid_event; 526 uint64_t events = 0; 527 uint64_t wait_start, max_wait; 528 struct rte_event ev; 529 530 max_wait = rte_get_timer_hz() * wait_sec; 531 wait_start = rte_get_timer_cycles(); 532 while (1) { 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."); 537 break; 538 } 539 540 valid_event = rte_event_dequeue_burst(evdev, 0, &ev, 1, 0); 541 if (!valid_event) 542 continue; 543 544 rte_mempool_put(eventdev_test_mempool, ev.event_ptr); 545 events++; 546 } 547 548 return TEST_SUCCESS; 549 } 550 551 static inline int 552 test_timer_arm(void) 553 { 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"); 558 return TEST_SUCCESS; 559 } 560 561 static inline int 562 test_timer_arm_periodic(void) 563 { 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. 568 */ 569 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, 10 * MAX_TIMERS, 0), 570 "Timer triggered count doesn't match arm count"); 571 return TEST_SUCCESS; 572 } 573 574 static int 575 _arm_wrapper(void *arg) 576 { 577 RTE_SET_USED(arg); 578 579 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS), 580 "Failed to arm timers"); 581 582 return TEST_SUCCESS; 583 } 584 585 static inline int 586 test_timer_arm_multicore(void) 587 { 588 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); 591 592 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_1); 593 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_2); 594 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"); 598 599 return TEST_SUCCESS; 600 } 601 602 #define MAX_BURST 16 603 static inline int 604 _arm_timers_burst(uint64_t timeout_tcks, uint64_t timers) 605 { 606 uint64_t i; 607 int j; 608 struct rte_event_timer *ev_tim[MAX_BURST]; 609 const struct rte_event_timer tim = { 610 .ev.op = RTE_EVENT_OP_NEW, 611 .ev.queue_id = 0, 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), 617 }; 618 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"); 624 625 for (j = 0; j < MAX_BURST; j++) { 626 *ev_tim[j] = tim; 627 ev_tim[j]->ev.event_ptr = ev_tim[j]; 628 } 629 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); 633 } 634 635 return TEST_SUCCESS; 636 } 637 638 static inline int 639 test_timer_arm_burst(void) 640 { 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"); 645 646 return TEST_SUCCESS; 647 } 648 649 static inline int 650 test_timer_arm_burst_periodic(void) 651 { 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. 656 */ 657 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, 10 * MAX_TIMERS, 0), 658 "Timer triggered count doesn't match arm count"); 659 660 return TEST_SUCCESS; 661 } 662 663 static int 664 _arm_wrapper_burst(void *arg) 665 { 666 RTE_SET_USED(arg); 667 668 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS), 669 "Failed to arm timers"); 670 671 return TEST_SUCCESS; 672 } 673 674 static inline int 675 test_timer_arm_burst_multicore(void) 676 { 677 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore1); 678 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore2); 679 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"); 683 684 return TEST_SUCCESS; 685 } 686 687 static inline int 688 test_timer_cancel_periodic(void) 689 { 690 uint64_t i; 691 struct rte_event_timer *ev_tim; 692 const struct rte_event_timer tim = { 693 .ev.op = RTE_EVENT_OP_NEW, 694 .ev.queue_id = 0, 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), 700 }; 701 702 for (i = 0; i < MAX_TIMERS; i++) { 703 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 704 (void **)&ev_tim), 705 "mempool alloc failed"); 706 *ev_tim = tim; 707 ev_tim->ev.event_ptr = ev_tim; 708 709 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 710 1), 1, "Failed to arm timer %d", 711 rte_errno); 712 713 rte_delay_us(100 + (i % 5000)); 714 715 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, 716 &ev_tim, 1), 1, 717 "Failed to cancel event timer %d", rte_errno); 718 rte_mempool_put(eventdev_test_mempool, ev_tim); 719 } 720 721 722 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 723 MAX_TIMERS), 724 "Timer triggered count doesn't match arm, cancel count"); 725 726 return TEST_SUCCESS; 727 } 728 729 static inline int 730 test_timer_cancel(void) 731 { 732 uint64_t i; 733 struct rte_event_timer *ev_tim; 734 const struct rte_event_timer tim = { 735 .ev.op = RTE_EVENT_OP_NEW, 736 .ev.queue_id = 0, 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), 742 }; 743 744 for (i = 0; i < MAX_TIMERS; i++) { 745 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 746 (void **)&ev_tim), 747 "mempool alloc failed"); 748 *ev_tim = tim; 749 ev_tim->ev.event_ptr = ev_tim; 750 751 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 752 1), 1, "Failed to arm timer %d", 753 rte_errno); 754 755 rte_delay_us(100 + (i % 5000)); 756 757 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, 758 &ev_tim, 1), 1, 759 "Failed to cancel event timer %d", rte_errno); 760 rte_mempool_put(eventdev_test_mempool, ev_tim); 761 } 762 763 764 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 765 MAX_TIMERS), 766 "Timer triggered count doesn't match arm, cancel count"); 767 768 return TEST_SUCCESS; 769 } 770 771 static int 772 _cancel_producer(uint64_t timeout_tcks, uint64_t timers) 773 { 774 uint64_t i; 775 struct rte_event_timer *ev_tim; 776 const struct rte_event_timer tim = { 777 .ev.op = RTE_EVENT_OP_NEW, 778 .ev.queue_id = 0, 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), 784 }; 785 786 for (i = 0; i < timers; i++) { 787 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 788 (void **)&ev_tim), 789 "mempool alloc failed"); 790 791 *ev_tim = tim; 792 ev_tim->ev.event_ptr = ev_tim; 793 794 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 795 1), 1, "Failed to arm timer %d", 796 rte_errno); 797 798 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED, 799 "Failed to arm event timer"); 800 801 while (rte_ring_enqueue(timer_producer_ring, ev_tim) != 0) 802 ; 803 } 804 805 return TEST_SUCCESS; 806 } 807 808 static int 809 _cancel_producer_burst(uint64_t timeout_tcks, uint64_t timers) 810 { 811 812 uint64_t i; 813 int j, ret; 814 struct rte_event_timer *ev_tim[MAX_BURST]; 815 const struct rte_event_timer tim = { 816 .ev.op = RTE_EVENT_OP_NEW, 817 .ev.queue_id = 0, 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), 823 }; 824 int arm_count = 0; 825 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"); 831 832 for (j = 0; j < MAX_BURST; j++) { 833 *ev_tim[j] = tim; 834 ev_tim[j]->ev.event_ptr = ev_tim[j]; 835 } 836 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); 840 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", 845 ev_tim[j]->state); 846 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"); 851 arm_count += ret; 852 } 853 854 TEST_ASSERT_EQUAL(arm_count, MAX_TIMERS, 855 "Failed to arm expected number of event timers"); 856 857 return TEST_SUCCESS; 858 } 859 860 static int 861 _cancel_producer_wrapper(void *args) 862 { 863 RTE_SET_USED(args); 864 865 return _cancel_producer(20, MAX_TIMERS); 866 } 867 868 static int 869 _cancel_producer_burst_wrapper(void *args) 870 { 871 RTE_SET_USED(args); 872 873 return _cancel_producer_burst(100, MAX_TIMERS); 874 } 875 876 static int 877 _cancel_thread(void *args) 878 { 879 RTE_SET_USED(args); 880 struct rte_event_timer *ev_tim = NULL; 881 uint64_t cancel_count = 0; 882 uint16_t ret; 883 884 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) { 885 if (rte_ring_dequeue(timer_producer_ring, (void **)&ev_tim)) 886 continue; 887 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); 891 cancel_count++; 892 } 893 894 return TEST_SUCCESS; 895 } 896 897 static int 898 _cancel_burst_thread(void *args) 899 { 900 RTE_SET_USED(args); 901 902 int ret, i, n; 903 struct rte_event_timer *ev_tim[MAX_BURST]; 904 uint64_t cancel_count = 0; 905 uint64_t dequeue_count = 0; 906 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); 910 if (!n) 911 continue; 912 913 dequeue_count += n; 914 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", 919 ev_tim[i]->state); 920 921 ret = rte_event_timer_cancel_burst(timdev, ev_tim, n); 922 TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of " 923 "event timers"); 924 rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim, 925 RTE_MIN(ret, MAX_BURST)); 926 927 cancel_count += ret; 928 } 929 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); 935 936 return TEST_SUCCESS; 937 } 938 939 static inline int 940 test_timer_cancel_multicore(void) 941 { 942 arm_done = 0; 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"); 947 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); 951 952 rte_eal_wait_lcore(test_lcore1); 953 rte_eal_wait_lcore(test_lcore2); 954 arm_done = 1; 955 rte_eal_wait_lcore(test_lcore3); 956 rte_ring_free(timer_producer_ring); 957 958 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS * 2, 959 MAX_TIMERS * 2), 960 "Timer triggered count doesn't match arm count"); 961 962 return TEST_SUCCESS; 963 } 964 965 static inline int 966 test_timer_cancel_burst_multicore(void) 967 { 968 arm_done = 0; 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"); 973 974 rte_eal_remote_launch(_cancel_burst_thread, NULL, test_lcore2); 975 rte_eal_remote_launch(_cancel_producer_burst_wrapper, NULL, 976 test_lcore1); 977 978 rte_eal_wait_lcore(test_lcore1); 979 arm_done = 1; 980 rte_eal_wait_lcore(test_lcore2); 981 rte_ring_free(timer_producer_ring); 982 983 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 984 MAX_TIMERS), 985 "Timer triggered count doesn't match arm count"); 986 987 return TEST_SUCCESS; 988 } 989 990 static inline int 991 test_timer_cancel_random(void) 992 { 993 uint64_t i; 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, 998 .ev.queue_id = 0, 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), 1004 }; 1005 1006 for (i = 0; i < MAX_TIMERS; i++) { 1007 1008 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 1009 (void **)&ev_tim), 1010 "mempool alloc failed"); 1011 *ev_tim = tim; 1012 ev_tim->ev.event_ptr = ev_tim; 1013 1014 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1015 1), 1, "Failed to arm timer %d", 1016 rte_errno); 1017 1018 if (rte_rand() & 1) { 1019 rte_delay_us(100 + (i % 5000)); 1020 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst( 1021 timdev, 1022 &ev_tim, 1), 1, 1023 "Failed to cancel event timer %d", rte_errno); 1024 rte_mempool_put(eventdev_test_mempool, ev_tim); 1025 events_canceled++; 1026 } 1027 } 1028 1029 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 1030 events_canceled), 1031 "Timer triggered count doesn't match arm, cancel count"); 1032 1033 return TEST_SUCCESS; 1034 } 1035 1036 /* Check that the adapter can be created correctly */ 1037 static int 1038 adapter_create(void) 1039 { 1040 int adapter_id = 0; 1041 struct rte_event_timer_adapter *adapter, *adapter2; 1042 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, 1051 }; 1052 uint32_t caps = 0; 1053 1054 /* Test invalid conf */ 1055 adapter = rte_event_timer_adapter_create(&conf); 1056 TEST_ASSERT_NULL(adapter, "Created adapter with invalid " 1057 "event device id"); 1058 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Incorrect errno value for " 1059 "invalid event device id"); 1060 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, 1067 test_port_conf_cb, 1068 NULL); 1069 else 1070 adapter = rte_event_timer_adapter_create(&conf); 1071 TEST_ASSERT_NOT_NULL(adapter, "Failed to create adapter with valid " 1072 "configuration"); 1073 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 " 1078 "id"); 1079 1080 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapter), 1081 "Failed to free adapter"); 1082 1083 return TEST_SUCCESS; 1084 } 1085 1086 1087 /* Test that adapter can be freed correctly. */ 1088 static int 1089 adapter_free(void) 1090 { 1091 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 1092 "Failed to stop adapter"); 1093 1094 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 1095 "Failed to free valid adapter"); 1096 1097 /* Test free of already freed adapter */ 1098 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 1099 "Freed adapter that was already freed"); 1100 1101 /* Test free of null adapter */ 1102 timdev = NULL; 1103 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 1104 "Freed null adapter"); 1105 1106 rte_mempool_free(eventdev_test_mempool); 1107 1108 return TEST_SUCCESS; 1109 } 1110 1111 /* Test that adapter info can be retrieved and is correct. */ 1112 static int 1113 adapter_get_info(void) 1114 { 1115 struct rte_event_timer_adapter_info info; 1116 1117 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_get_info(timdev, &info), 1118 "Failed to get adapter info"); 1119 1120 if (using_services) 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); 1124 1125 return TEST_SUCCESS; 1126 } 1127 1128 /* Test adapter lookup via adapter ID. */ 1129 static int 1130 adapter_lookup(void) 1131 { 1132 struct rte_event_timer_adapter *adapter; 1133 1134 adapter = rte_event_timer_adapter_lookup(TEST_ADAPTER_ID); 1135 TEST_ASSERT_NOT_NULL(adapter, "Failed to lookup adapter"); 1136 1137 return TEST_SUCCESS; 1138 } 1139 1140 static int 1141 adapter_start(void) 1142 { 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."); 1148 1149 return TEST_SUCCESS; 1150 } 1151 1152 /* Test that adapter stops correctly. */ 1153 static int 1154 adapter_stop(void) 1155 { 1156 struct rte_event_timer_adapter *l_adapter = NULL; 1157 1158 /* Test adapter stop */ 1159 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 1160 "Failed to stop event adapter"); 1161 1162 TEST_ASSERT_FAIL(rte_event_timer_adapter_stop(l_adapter), 1163 "Erroneously stopped null event adapter"); 1164 1165 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 1166 "Failed to free adapter"); 1167 1168 rte_mempool_free(eventdev_test_mempool); 1169 1170 return TEST_SUCCESS; 1171 } 1172 1173 /* Test increment and reset of ev_enq_count stat */ 1174 static int 1175 stat_inc_reset_ev_enq(void) 1176 { 1177 int ret, i, n; 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 1190 }; 1191 1192 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1193 num_evtims); 1194 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1195 ret); 1196 1197 for (i = 0; i < num_evtims; i++) { 1198 *evtims[i] = init_tim; 1199 evtims[i]->ev.event_ptr = evtims[i]; 1200 } 1201 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 " 1205 "startup"); 1206 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)); 1213 1214 rte_delay_ms(1000); 1215 1216 #define MAX_TRIES num_evtims 1217 int sum = 0; 1218 int tries = 0; 1219 bool done = false; 1220 while (!done) { 1221 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1222 RTE_DIM(evs), 10); 1223 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1224 done = true; 1225 1226 rte_delay_ms(10); 1227 } 1228 1229 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1230 "got %d", num_evtims, sum); 1231 1232 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1233 1234 rte_delay_ms(100); 1235 1236 /* Make sure the eventdev is still empty */ 1237 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1238 10); 1239 1240 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1241 "events from event device"); 1242 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); 1249 1250 /* Reset and check again */ 1251 ret = rte_event_timer_adapter_stats_reset(timdev); 1252 TEST_ASSERT_EQUAL(ret, 0, "Failed to reset stats"); 1253 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); 1259 1260 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1261 num_evtims); 1262 1263 return TEST_SUCCESS; 1264 } 1265 1266 /* Test various cases in arming timers */ 1267 static int 1268 event_timer_arm(void) 1269 { 1270 uint16_t n; 1271 int ret; 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 1283 }; 1284 1285 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1286 if (evtim == NULL) { 1287 /* Failed to get an event timer object */ 1288 return TEST_FAILED; 1289 } 1290 1291 /* Set up a timer */ 1292 *evtim = init_tim; 1293 evtim->ev.event_ptr = evtim; 1294 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"); 1301 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"); 1308 1309 /* Let timer expire */ 1310 rte_delay_ms(1000); 1311 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"); 1315 1316 rte_mempool_put(eventdev_test_mempool, evtim); 1317 1318 return TEST_SUCCESS; 1319 } 1320 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. 1323 */ 1324 static int 1325 event_timer_arm_double(void) 1326 { 1327 uint16_t n; 1328 int ret; 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 1340 }; 1341 1342 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1343 if (evtim == NULL) { 1344 /* Failed to get an event timer object */ 1345 return TEST_FAILED; 1346 } 1347 1348 /* Set up a timer */ 1349 *evtim = init_tim; 1350 evtim->ev.event_ptr = evtim; 1351 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"); 1358 1359 /* Let timer expire */ 1360 rte_delay_ms(600); 1361 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); 1365 1366 rte_mempool_put(eventdev_test_mempool, evtim); 1367 1368 return TEST_SUCCESS; 1369 } 1370 1371 /* Test the timer expiry event is generated at the expected time. */ 1372 static int 1373 event_timer_arm_expiry(void) 1374 { 1375 uint16_t n; 1376 int ret; 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, 1388 }; 1389 1390 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1391 if (evtim == NULL) { 1392 /* Failed to get an event timer object */ 1393 return TEST_FAILED; 1394 } 1395 1396 /* Set up an event timer */ 1397 *evtim = init_tim; 1398 evtim->timeout_ticks = CALC_TICKS(30), // expire in 3 secs 1399 evtim->ev.event_ptr = evtim; 1400 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"); 1406 1407 rte_delay_ms(2999); 1408 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"); 1411 1412 /* Delay 100 ms to account for the adapter tick window - should let us 1413 * dequeue one event 1414 */ 1415 rte_delay_ms(100); 1416 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"); 1422 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); 1428 1429 return TEST_SUCCESS; 1430 } 1431 1432 /* Check that rearming a timer works as expected. */ 1433 static int 1434 event_timer_arm_rearm(void) 1435 { 1436 uint16_t n; 1437 int ret; 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, 1448 }; 1449 1450 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1451 if (evtim == NULL) { 1452 /* Failed to get an event timer object */ 1453 return TEST_FAILED; 1454 } 1455 1456 /* Set up a timer */ 1457 *evtim = init_tim; 1458 evtim->timeout_ticks = CALC_TICKS(1); // expire in 0.1 sec 1459 evtim->ev.event_ptr = evtim; 1460 1461 /* Arm it */ 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)); 1465 1466 /* Add 100ms to account for the adapter tick window */ 1467 rte_delay_ms(100 + 100); 1468 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"); 1472 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"); 1477 1478 /* Need to reset state in case implementation can't do it */ 1479 evtim2->state = RTE_EVENT_TIMER_NOT_ARMED; 1480 1481 /* Rearm it */ 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)); 1485 1486 /* Add 100ms to account for the adapter tick window */ 1487 rte_delay_ms(100 + 100); 1488 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"); 1492 1493 /* Free it */ 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); 1498 1499 return TEST_SUCCESS; 1500 } 1501 1502 /* Check that the adapter handles the max specified number of timers as 1503 * expected. 1504 */ 1505 static int 1506 event_timer_arm_max(void) 1507 { 1508 int ret, i, n; 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 1520 }; 1521 1522 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1523 num_evtims); 1524 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1525 ret); 1526 1527 for (i = 0; i < num_evtims; i++) { 1528 *evtims[i] = init_tim; 1529 evtims[i]->ev.event_ptr = evtims[i]; 1530 } 1531 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)); 1538 1539 rte_delay_ms(1000); 1540 1541 #define MAX_TRIES num_evtims 1542 int sum = 0; 1543 int tries = 0; 1544 bool done = false; 1545 while (!done) { 1546 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1547 RTE_DIM(evs), 10); 1548 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1549 done = true; 1550 1551 rte_delay_ms(10); 1552 } 1553 1554 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1555 "got %d", num_evtims, sum); 1556 1557 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1558 1559 rte_delay_ms(100); 1560 1561 /* Make sure the eventdev is still empty */ 1562 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1563 10); 1564 1565 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1566 "events from event device"); 1567 1568 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1569 num_evtims); 1570 1571 return TEST_SUCCESS; 1572 } 1573 1574 /* Check that creating an event timer with incorrect event sched type fails. */ 1575 static int 1576 event_timer_arm_invalid_sched_type(void) 1577 { 1578 int ret; 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 1588 }; 1589 1590 if (!using_services) 1591 return -ENOTSUP; 1592 1593 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1594 if (evtim == NULL) { 1595 /* Failed to get an event timer object */ 1596 return TEST_FAILED; 1597 } 1598 1599 *evtim = init_tim; 1600 evtim->ev.event_ptr = evtim; 1601 evtim->ev.sched_type = RTE_SCHED_TYPE_PARALLEL; // bad sched type 1602 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"); 1608 1609 rte_mempool_put(eventdev_test_mempool, &evtim); 1610 1611 return TEST_SUCCESS; 1612 } 1613 1614 /* Check that creating an event timer with a timeout value that is too small or 1615 * too big fails. 1616 */ 1617 static int 1618 event_timer_arm_invalid_timeout(void) 1619 { 1620 int ret; 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 1630 }; 1631 1632 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1633 if (evtim == NULL) { 1634 /* Failed to get an event timer object */ 1635 return TEST_FAILED; 1636 } 1637 1638 *evtim = init_tim; 1639 evtim->ev.event_ptr = evtim; 1640 evtim->timeout_ticks = 0; // timeout too small 1641 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"); 1649 1650 *evtim = init_tim; 1651 evtim->ev.event_ptr = evtim; 1652 evtim->timeout_ticks = CALC_TICKS(1801); // timeout too big 1653 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"); 1661 1662 rte_mempool_put(eventdev_test_mempool, evtim); 1663 1664 return TEST_SUCCESS; 1665 } 1666 1667 static int 1668 event_timer_cancel(void) 1669 { 1670 uint16_t n; 1671 int ret; 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, 1682 }; 1683 1684 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1685 if (evtim == NULL) { 1686 /* Failed to get an event timer object */ 1687 return TEST_FAILED; 1688 } 1689 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 " 1693 "uninited timer"); 1694 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1695 "cancelling uninited timer"); 1696 1697 /* Set up a timer */ 1698 *evtim = init_tim; 1699 evtim->ev.event_ptr = evtim; 1700 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1701 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 " 1705 "unarmed timer"); 1706 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1707 "cancelling unarmed timer"); 1708 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"); 1714 1715 /* Delay 1 sec */ 1716 rte_delay_ms(1000); 1717 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"); 1723 1724 rte_delay_ms(3000); 1725 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"); 1729 1730 rte_mempool_put(eventdev_test_mempool, evtim); 1731 1732 return TEST_SUCCESS; 1733 } 1734 1735 static int 1736 event_timer_cancel_double(void) 1737 { 1738 uint16_t n; 1739 int ret; 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 1751 }; 1752 1753 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1754 if (evtim == NULL) { 1755 /* Failed to get an event timer object */ 1756 return TEST_FAILED; 1757 } 1758 1759 /* Set up a timer */ 1760 *evtim = init_tim; 1761 evtim->ev.event_ptr = evtim; 1762 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1763 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"); 1769 1770 /* Now, test that referencing the same timer twice in the same call 1771 * fails 1772 */ 1773 struct rte_event_timer *evtim_arr[] = {evtim, evtim}; 1774 ret = rte_event_timer_cancel_burst(adapter, evtim_arr, 1775 RTE_DIM(evtim_arr)); 1776 1777 /* Two requests to cancel same timer, only one should succeed */ 1778 TEST_ASSERT_EQUAL(ret, 1, "Succeeded unexpectedly in canceling timer " 1779 "twice"); 1780 1781 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1782 "after double-cancel: rte_errno = %d", rte_errno); 1783 1784 rte_delay_ms(3000); 1785 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"); 1789 1790 rte_mempool_put(eventdev_test_mempool, evtim); 1791 1792 return TEST_SUCCESS; 1793 } 1794 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. 1797 */ 1798 static int 1799 adapter_tick_resolution(void) 1800 { 1801 struct rte_event_timer_adapter_stats stats; 1802 uint64_t adapter_tick_count; 1803 1804 /* Only run this test in the software driver case */ 1805 if (!using_services) 1806 return -ENOTSUP; 1807 1808 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_reset(timdev), 1809 "Failed to reset stats"); 1810 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 " 1814 "not zeroed out"); 1815 1816 /* Delay 1 second; should let at least 10 ticks occur with the default 1817 * adapter configuration used by this test. 1818 */ 1819 rte_delay_ms(1000); 1820 1821 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev, 1822 &stats), "Failed to get adapter stats"); 1823 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); 1828 1829 return TEST_SUCCESS; 1830 } 1831 1832 static int 1833 adapter_create_max(void) 1834 { 1835 int i; 1836 uint32_t svc_start_count, svc_end_count; 1837 struct rte_event_timer_adapter *adapters[ 1838 RTE_EVENT_TIMER_ADAPTER_NUM_MAX + 1]; 1839 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, 1848 }; 1849 1850 if (!using_services) 1851 return -ENOTSUP; 1852 1853 svc_start_count = rte_service_get_count(); 1854 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). 1859 */ 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 " 1865 "%d", i); 1866 } 1867 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"); 1871 1872 /* Check that at least RTE_EVENT_TIMER_ADAPTER_NUM_MAX services 1873 * have been created 1874 */ 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"); 1879 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); 1883 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"); 1888 1889 return TEST_SUCCESS; 1890 } 1891 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, 1898 test_timer_state), 1899 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1900 test_timer_arm), 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, 1908 test_timer_cancel), 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, 1924 adapter_get_info), 1925 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1926 adapter_lookup), 1927 TEST_CASE_ST(NULL, timdev_teardown, 1928 adapter_start), 1929 TEST_CASE_ST(timdev_setup_msec, NULL, 1930 adapter_stop), 1931 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1932 stat_inc_reset_ev_enq), 1933 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1934 event_timer_arm), 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 */ 1955 } 1956 }; 1957 1958 static int 1959 test_event_timer_adapter_func(void) 1960 { 1961 return unit_test_suite_runner(&event_timer_adptr_functional_testsuite); 1962 } 1963 1964 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1965 1966 REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func); 1967