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