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 uint32_t caps = 0; 390 uint64_t max_tmo_ns; 391 392 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES | 393 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC; 394 395 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 396 "failed to get adapter capabilities"); 397 398 if (caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT) 399 max_tmo_ns = 0; 400 else 401 max_tmo_ns = 180 * NSECPERSEC; 402 403 /* Periodic mode with 100 ms resolution */ 404 return _timdev_setup(max_tmo_ns, NSECPERSEC / 10, flags); 405 } 406 407 static int 408 timdev_setup_sec(void) 409 { 410 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 411 412 /* Max timeout is 100sec and bucket interval is 1sec */ 413 return _timdev_setup(1E11, 1E9, flags); 414 } 415 416 static int 417 timdev_setup_sec_periodic(void) 418 { 419 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES | 420 RTE_EVENT_TIMER_ADAPTER_F_PERIODIC; 421 422 /* Periodic mode with 1 sec resolution */ 423 return _timdev_setup(180 * NSECPERSEC, NSECPERSEC, flags); 424 } 425 426 static int 427 timdev_setup_sec_multicore(void) 428 { 429 uint64_t flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES; 430 431 /* Max timeout is 100sec and bucket interval is 1sec */ 432 return _timdev_setup(1E11, 1E9, flags); 433 } 434 435 static void 436 timdev_teardown(void) 437 { 438 rte_event_timer_adapter_stop(timdev); 439 rte_event_timer_adapter_free(timdev); 440 441 rte_mempool_free(eventdev_test_mempool); 442 } 443 444 static inline int 445 test_timer_state(void) 446 { 447 struct rte_event_timer *ev_tim; 448 struct rte_event ev; 449 const struct rte_event_timer tim = { 450 .ev.op = RTE_EVENT_OP_NEW, 451 .ev.queue_id = 0, 452 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 453 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 454 .ev.event_type = RTE_EVENT_TYPE_TIMER, 455 .state = RTE_EVENT_TIMER_NOT_ARMED, 456 }; 457 458 459 rte_mempool_get(eventdev_test_mempool, (void **)&ev_tim); 460 *ev_tim = tim; 461 ev_tim->ev.event_ptr = ev_tim; 462 ev_tim->timeout_ticks = CALC_TICKS(120); 463 464 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 0, 465 "Armed timer exceeding max_timeout."); 466 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ERROR_TOOLATE, 467 "Improper timer state set expected %d returned %d", 468 RTE_EVENT_TIMER_ERROR_TOOLATE, ev_tim->state); 469 470 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED; 471 ev_tim->timeout_ticks = CALC_TICKS(10); 472 473 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1, 474 "Failed to arm timer with proper timeout."); 475 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED, 476 "Improper timer state set expected %d returned %d", 477 RTE_EVENT_TIMER_ARMED, ev_tim->state); 478 479 if (!using_services) 480 rte_delay_us(20); 481 else 482 rte_delay_us(1000 + 200); 483 TEST_ASSERT_EQUAL(rte_event_dequeue_burst(evdev, 0, &ev, 1, 0), 1, 484 "Armed timer failed to trigger."); 485 486 ev_tim->state = RTE_EVENT_TIMER_NOT_ARMED; 487 ev_tim->timeout_ticks = CALC_TICKS(90); 488 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1), 1, 489 "Failed to arm timer with proper timeout."); 490 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, &ev_tim, 1), 491 1, "Failed to cancel armed timer"); 492 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_CANCELED, 493 "Improper timer state set expected %d returned %d", 494 RTE_EVENT_TIMER_CANCELED, ev_tim->state); 495 496 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim); 497 498 return TEST_SUCCESS; 499 } 500 501 static inline int 502 _arm_timers(uint64_t timeout_tcks, uint64_t timers) 503 { 504 uint64_t i; 505 struct rte_event_timer *ev_tim; 506 const struct rte_event_timer tim = { 507 .ev.op = RTE_EVENT_OP_NEW, 508 .ev.queue_id = 0, 509 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 510 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 511 .ev.event_type = RTE_EVENT_TYPE_TIMER, 512 .state = RTE_EVENT_TIMER_NOT_ARMED, 513 .timeout_ticks = CALC_TICKS(timeout_tcks), 514 }; 515 516 for (i = 0; i < timers; i++) { 517 518 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 519 (void **)&ev_tim), 520 "mempool alloc failed"); 521 *ev_tim = tim; 522 ev_tim->ev.event_ptr = ev_tim; 523 524 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 525 1), 1, "Failed to arm timer %d", 526 rte_errno); 527 } 528 529 return TEST_SUCCESS; 530 } 531 532 static inline int 533 _wait_timer_triggers(uint64_t wait_sec, uint64_t arm_count, 534 uint64_t cancel_count) 535 { 536 uint8_t valid_event; 537 uint64_t events = 0; 538 uint64_t wait_start, max_wait; 539 struct rte_event ev; 540 541 max_wait = rte_get_timer_hz() * wait_sec; 542 wait_start = rte_get_timer_cycles(); 543 while (1) { 544 if (rte_get_timer_cycles() - wait_start > max_wait) { 545 if (events + cancel_count != arm_count) 546 TEST_ASSERT_SUCCESS(max_wait, 547 "Max time limit for timers exceeded."); 548 break; 549 } 550 551 valid_event = rte_event_dequeue_burst(evdev, 0, &ev, 1, 0); 552 if (!valid_event) 553 continue; 554 555 rte_mempool_put(eventdev_test_mempool, ev.event_ptr); 556 events++; 557 } 558 559 return TEST_SUCCESS; 560 } 561 562 static inline int 563 test_timer_arm(void) 564 { 565 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS), 566 "Failed to arm timers"); 567 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0), 568 "Timer triggered count doesn't match arm count"); 569 return TEST_SUCCESS; 570 } 571 572 static inline int 573 test_timer_arm_periodic(void) 574 { 575 uint32_t caps = 0; 576 uint32_t timeout_count = 0; 577 578 TEST_ASSERT_SUCCESS(_arm_timers(1, MAX_TIMERS), 579 "Failed to arm timers"); 580 /* With a resolution of 100ms and wait time of 1sec, 581 * there will be 10 * MAX_TIMERS periodic timer triggers. 582 */ 583 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 584 "failed to get adapter capabilities"); 585 586 if (caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT) 587 timeout_count = 10; 588 else 589 timeout_count = 9; 590 591 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, timeout_count * MAX_TIMERS, 0), 592 "Timer triggered count doesn't match arm count"); 593 return TEST_SUCCESS; 594 } 595 596 static int 597 _arm_wrapper(void *arg) 598 { 599 RTE_SET_USED(arg); 600 601 TEST_ASSERT_SUCCESS(_arm_timers(20, MAX_TIMERS), 602 "Failed to arm timers"); 603 604 return TEST_SUCCESS; 605 } 606 607 static inline int 608 test_timer_arm_multicore(void) 609 { 610 611 uint32_t lcore_1 = rte_get_next_lcore(-1, 1, 0); 612 uint32_t lcore_2 = rte_get_next_lcore(lcore_1, 1, 0); 613 614 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_1); 615 rte_eal_remote_launch(_arm_wrapper, NULL, lcore_2); 616 617 rte_eal_mp_wait_lcore(); 618 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0), 619 "Timer triggered count doesn't match arm count"); 620 621 return TEST_SUCCESS; 622 } 623 624 #define MAX_BURST 16 625 static inline int 626 _arm_timers_burst(uint64_t timeout_tcks, uint64_t timers) 627 { 628 uint64_t i; 629 int j; 630 struct rte_event_timer *ev_tim[MAX_BURST]; 631 const struct rte_event_timer tim = { 632 .ev.op = RTE_EVENT_OP_NEW, 633 .ev.queue_id = 0, 634 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 635 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 636 .ev.event_type = RTE_EVENT_TYPE_TIMER, 637 .state = RTE_EVENT_TIMER_NOT_ARMED, 638 .timeout_ticks = CALC_TICKS(timeout_tcks), 639 }; 640 641 for (i = 0; i < timers / MAX_BURST; i++) { 642 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk( 643 eventdev_test_mempool, 644 (void **)ev_tim, MAX_BURST), 645 "mempool alloc failed"); 646 647 for (j = 0; j < MAX_BURST; j++) { 648 *ev_tim[j] = tim; 649 ev_tim[j]->ev.event_ptr = ev_tim[j]; 650 } 651 652 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev, 653 ev_tim, tim.timeout_ticks, MAX_BURST), 654 MAX_BURST, "Failed to arm timer %d", rte_errno); 655 } 656 657 return TEST_SUCCESS; 658 } 659 660 static inline int 661 test_timer_arm_burst(void) 662 { 663 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS), 664 "Failed to arm timers"); 665 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS, 0), 666 "Timer triggered count doesn't match arm count"); 667 668 return TEST_SUCCESS; 669 } 670 671 static inline int 672 test_timer_arm_burst_periodic(void) 673 { 674 uint32_t caps = 0; 675 uint32_t timeout_count = 0; 676 677 TEST_ASSERT_SUCCESS(_arm_timers_burst(1, MAX_TIMERS), 678 "Failed to arm timers"); 679 /* With a resolution of 100ms and wait time of 1sec, 680 * there will be 10 * MAX_TIMERS periodic timer triggers. 681 */ 682 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 683 "failed to get adapter capabilities"); 684 685 if (caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT) 686 timeout_count = 10; 687 else 688 timeout_count = 9; 689 690 TEST_ASSERT_SUCCESS(_wait_timer_triggers(1, timeout_count * MAX_TIMERS, 0), 691 "Timer triggered count doesn't match arm count"); 692 693 return TEST_SUCCESS; 694 } 695 696 static int 697 _arm_wrapper_burst(void *arg) 698 { 699 RTE_SET_USED(arg); 700 701 TEST_ASSERT_SUCCESS(_arm_timers_burst(20, MAX_TIMERS), 702 "Failed to arm timers"); 703 704 return TEST_SUCCESS; 705 } 706 707 static inline int 708 test_timer_arm_burst_multicore(void) 709 { 710 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore1); 711 rte_eal_remote_launch(_arm_wrapper_burst, NULL, test_lcore2); 712 713 rte_eal_mp_wait_lcore(); 714 TEST_ASSERT_SUCCESS(_wait_timer_triggers(10, MAX_TIMERS * 2, 0), 715 "Timer triggered count doesn't match arm count"); 716 717 return TEST_SUCCESS; 718 } 719 720 static inline int 721 test_timer_cancel_periodic(void) 722 { 723 uint64_t i; 724 struct rte_event_timer *ev_tim; 725 const struct rte_event_timer tim = { 726 .ev.op = RTE_EVENT_OP_NEW, 727 .ev.queue_id = 0, 728 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 729 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 730 .ev.event_type = RTE_EVENT_TYPE_TIMER, 731 .state = RTE_EVENT_TIMER_NOT_ARMED, 732 .timeout_ticks = CALC_TICKS(1), 733 }; 734 735 for (i = 0; i < MAX_TIMERS; i++) { 736 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 737 (void **)&ev_tim), 738 "mempool alloc failed"); 739 *ev_tim = tim; 740 ev_tim->ev.event_ptr = ev_tim; 741 742 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 743 1), 1, "Failed to arm timer %d", 744 rte_errno); 745 746 rte_delay_us(100 + (i % 5000)); 747 748 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, 749 &ev_tim, 1), 1, 750 "Failed to cancel event timer %d", rte_errno); 751 rte_mempool_put(eventdev_test_mempool, ev_tim); 752 } 753 754 755 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 756 MAX_TIMERS), 757 "Timer triggered count doesn't match arm, cancel count"); 758 759 return TEST_SUCCESS; 760 } 761 762 static inline int 763 test_timer_cancel(void) 764 { 765 uint64_t i; 766 struct rte_event_timer *ev_tim; 767 const struct rte_event_timer tim = { 768 .ev.op = RTE_EVENT_OP_NEW, 769 .ev.queue_id = 0, 770 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 771 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 772 .ev.event_type = RTE_EVENT_TYPE_TIMER, 773 .state = RTE_EVENT_TIMER_NOT_ARMED, 774 .timeout_ticks = CALC_TICKS(20), 775 }; 776 777 for (i = 0; i < MAX_TIMERS; i++) { 778 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 779 (void **)&ev_tim), 780 "mempool alloc failed"); 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 rte_delay_us(100 + (i % 5000)); 789 790 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst(timdev, 791 &ev_tim, 1), 1, 792 "Failed to cancel event timer %d", rte_errno); 793 rte_mempool_put(eventdev_test_mempool, ev_tim); 794 } 795 796 797 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 798 MAX_TIMERS), 799 "Timer triggered count doesn't match arm, cancel count"); 800 801 return TEST_SUCCESS; 802 } 803 804 static int 805 _cancel_producer(uint64_t timeout_tcks, uint64_t timers) 806 { 807 uint64_t i; 808 struct rte_event_timer *ev_tim; 809 const struct rte_event_timer tim = { 810 .ev.op = RTE_EVENT_OP_NEW, 811 .ev.queue_id = 0, 812 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 813 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 814 .ev.event_type = RTE_EVENT_TYPE_TIMER, 815 .state = RTE_EVENT_TIMER_NOT_ARMED, 816 .timeout_ticks = CALC_TICKS(timeout_tcks), 817 }; 818 819 for (i = 0; i < timers; i++) { 820 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 821 (void **)&ev_tim), 822 "mempool alloc failed"); 823 824 *ev_tim = tim; 825 ev_tim->ev.event_ptr = ev_tim; 826 827 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 828 1), 1, "Failed to arm timer %d", 829 rte_errno); 830 831 TEST_ASSERT_EQUAL(ev_tim->state, RTE_EVENT_TIMER_ARMED, 832 "Failed to arm event timer"); 833 834 while (rte_ring_enqueue(timer_producer_ring, ev_tim) != 0) 835 ; 836 } 837 838 return TEST_SUCCESS; 839 } 840 841 static int 842 _cancel_producer_burst(uint64_t timeout_tcks, uint64_t timers) 843 { 844 845 uint64_t i; 846 int j, ret; 847 struct rte_event_timer *ev_tim[MAX_BURST]; 848 const struct rte_event_timer tim = { 849 .ev.op = RTE_EVENT_OP_NEW, 850 .ev.queue_id = 0, 851 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 852 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 853 .ev.event_type = RTE_EVENT_TYPE_TIMER, 854 .state = RTE_EVENT_TIMER_NOT_ARMED, 855 .timeout_ticks = CALC_TICKS(timeout_tcks), 856 }; 857 int arm_count = 0; 858 859 for (i = 0; i < timers / MAX_BURST; i++) { 860 TEST_ASSERT_SUCCESS(rte_mempool_get_bulk( 861 eventdev_test_mempool, 862 (void **)ev_tim, MAX_BURST), 863 "mempool alloc failed"); 864 865 for (j = 0; j < MAX_BURST; j++) { 866 *ev_tim[j] = tim; 867 ev_tim[j]->ev.event_ptr = ev_tim[j]; 868 } 869 870 TEST_ASSERT_EQUAL(rte_event_timer_arm_tmo_tick_burst(timdev, 871 ev_tim, tim.timeout_ticks, MAX_BURST), 872 MAX_BURST, "Failed to arm timer %d", rte_errno); 873 874 for (j = 0; j < MAX_BURST; j++) 875 TEST_ASSERT_EQUAL(ev_tim[j]->state, 876 RTE_EVENT_TIMER_ARMED, 877 "Event timer not armed, state = %d", 878 ev_tim[j]->state); 879 880 ret = rte_ring_enqueue_bulk(timer_producer_ring, 881 (void **)ev_tim, MAX_BURST, NULL); 882 TEST_ASSERT_EQUAL(ret, MAX_BURST, 883 "Failed to enqueue event timers to ring"); 884 arm_count += ret; 885 } 886 887 TEST_ASSERT_EQUAL(arm_count, MAX_TIMERS, 888 "Failed to arm expected number of event timers"); 889 890 return TEST_SUCCESS; 891 } 892 893 static int 894 _cancel_producer_wrapper(void *args) 895 { 896 RTE_SET_USED(args); 897 898 return _cancel_producer(20, MAX_TIMERS); 899 } 900 901 static int 902 _cancel_producer_burst_wrapper(void *args) 903 { 904 RTE_SET_USED(args); 905 906 return _cancel_producer_burst(100, MAX_TIMERS); 907 } 908 909 static int 910 _cancel_thread(void *args) 911 { 912 RTE_SET_USED(args); 913 struct rte_event_timer *ev_tim = NULL; 914 uint64_t cancel_count = 0; 915 uint16_t ret; 916 917 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) { 918 if (rte_ring_dequeue(timer_producer_ring, (void **)&ev_tim)) 919 continue; 920 921 ret = rte_event_timer_cancel_burst(timdev, &ev_tim, 1); 922 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel timer"); 923 rte_mempool_put(eventdev_test_mempool, (void *)ev_tim); 924 cancel_count++; 925 } 926 927 return TEST_SUCCESS; 928 } 929 930 static int 931 _cancel_burst_thread(void *args) 932 { 933 RTE_SET_USED(args); 934 935 int ret, i, n; 936 struct rte_event_timer *ev_tim[MAX_BURST]; 937 uint64_t cancel_count = 0; 938 uint64_t dequeue_count = 0; 939 940 while (!arm_done || rte_ring_count(timer_producer_ring) > 0) { 941 n = rte_ring_dequeue_burst(timer_producer_ring, 942 (void **)ev_tim, MAX_BURST, NULL); 943 if (!n) 944 continue; 945 946 dequeue_count += n; 947 948 for (i = 0; i < n; i++) 949 TEST_ASSERT_EQUAL(ev_tim[i]->state, 950 RTE_EVENT_TIMER_ARMED, 951 "Event timer not armed, state = %d", 952 ev_tim[i]->state); 953 954 ret = rte_event_timer_cancel_burst(timdev, ev_tim, n); 955 TEST_ASSERT_EQUAL(n, ret, "Failed to cancel complete burst of " 956 "event timers"); 957 rte_mempool_put_bulk(eventdev_test_mempool, (void **)ev_tim, 958 RTE_MIN(ret, MAX_BURST)); 959 960 cancel_count += ret; 961 } 962 963 TEST_ASSERT_EQUAL(cancel_count, MAX_TIMERS, 964 "Failed to cancel expected number of timers: " 965 "expected = %d, cancel_count = %"PRIu64", " 966 "dequeue_count = %"PRIu64"\n", MAX_TIMERS, 967 cancel_count, dequeue_count); 968 969 return TEST_SUCCESS; 970 } 971 972 static inline int 973 test_timer_cancel_multicore(void) 974 { 975 arm_done = 0; 976 timer_producer_ring = rte_ring_create("timer_cancel_queue", 977 MAX_TIMERS * 2, rte_socket_id(), 0); 978 TEST_ASSERT_NOT_NULL(timer_producer_ring, 979 "Unable to reserve memory for ring"); 980 981 rte_eal_remote_launch(_cancel_thread, NULL, test_lcore3); 982 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore1); 983 rte_eal_remote_launch(_cancel_producer_wrapper, NULL, test_lcore2); 984 985 rte_eal_wait_lcore(test_lcore1); 986 rte_eal_wait_lcore(test_lcore2); 987 arm_done = 1; 988 rte_eal_wait_lcore(test_lcore3); 989 rte_ring_free(timer_producer_ring); 990 991 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS * 2, 992 MAX_TIMERS * 2), 993 "Timer triggered count doesn't match arm count"); 994 995 return TEST_SUCCESS; 996 } 997 998 static inline int 999 test_timer_cancel_burst_multicore(void) 1000 { 1001 arm_done = 0; 1002 timer_producer_ring = rte_ring_create("timer_cancel_queue", 1003 MAX_TIMERS * 2, rte_socket_id(), 0); 1004 TEST_ASSERT_NOT_NULL(timer_producer_ring, 1005 "Unable to reserve memory for ring"); 1006 1007 rte_eal_remote_launch(_cancel_burst_thread, NULL, test_lcore2); 1008 rte_eal_remote_launch(_cancel_producer_burst_wrapper, NULL, 1009 test_lcore1); 1010 1011 rte_eal_wait_lcore(test_lcore1); 1012 arm_done = 1; 1013 rte_eal_wait_lcore(test_lcore2); 1014 rte_ring_free(timer_producer_ring); 1015 1016 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 1017 MAX_TIMERS), 1018 "Timer triggered count doesn't match arm count"); 1019 1020 return TEST_SUCCESS; 1021 } 1022 1023 static inline int 1024 test_timer_cancel_random(void) 1025 { 1026 uint64_t i; 1027 uint64_t events_canceled = 0; 1028 struct rte_event_timer *ev_tim; 1029 const struct rte_event_timer tim = { 1030 .ev.op = RTE_EVENT_OP_NEW, 1031 .ev.queue_id = 0, 1032 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1033 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1034 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1035 .state = RTE_EVENT_TIMER_NOT_ARMED, 1036 .timeout_ticks = CALC_TICKS(20), 1037 }; 1038 1039 for (i = 0; i < MAX_TIMERS; i++) { 1040 1041 TEST_ASSERT_SUCCESS(rte_mempool_get(eventdev_test_mempool, 1042 (void **)&ev_tim), 1043 "mempool alloc failed"); 1044 *ev_tim = tim; 1045 ev_tim->ev.event_ptr = ev_tim; 1046 1047 TEST_ASSERT_EQUAL(rte_event_timer_arm_burst(timdev, &ev_tim, 1048 1), 1, "Failed to arm timer %d", 1049 rte_errno); 1050 1051 if (rte_rand() & 1) { 1052 rte_delay_us(100 + (i % 5000)); 1053 TEST_ASSERT_EQUAL(rte_event_timer_cancel_burst( 1054 timdev, 1055 &ev_tim, 1), 1, 1056 "Failed to cancel event timer %d", rte_errno); 1057 rte_mempool_put(eventdev_test_mempool, ev_tim); 1058 events_canceled++; 1059 } 1060 } 1061 1062 TEST_ASSERT_SUCCESS(_wait_timer_triggers(30, MAX_TIMERS, 1063 events_canceled), 1064 "Timer triggered count doesn't match arm, cancel count"); 1065 1066 return TEST_SUCCESS; 1067 } 1068 1069 /* Check that the adapter can be created correctly */ 1070 static int 1071 adapter_create(void) 1072 { 1073 int adapter_id = 0; 1074 struct rte_event_timer_adapter *adapter, *adapter2; 1075 1076 struct rte_event_timer_adapter_conf conf = { 1077 .event_dev_id = evdev + 1, // invalid event dev id 1078 .timer_adapter_id = adapter_id, 1079 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK, 1080 .timer_tick_ns = NSECPERSEC / 10, 1081 .max_tmo_ns = 180 * NSECPERSEC, 1082 .nb_timers = MAX_TIMERS, 1083 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, 1084 }; 1085 uint32_t caps = 0; 1086 1087 /* Test invalid conf */ 1088 adapter = rte_event_timer_adapter_create(&conf); 1089 TEST_ASSERT_NULL(adapter, "Created adapter with invalid " 1090 "event device id"); 1091 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Incorrect errno value for " 1092 "invalid event device id"); 1093 1094 /* Test valid conf */ 1095 conf.event_dev_id = evdev; 1096 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_caps_get(evdev, &caps), 1097 "failed to get adapter capabilities"); 1098 if (!(caps & RTE_EVENT_TIMER_ADAPTER_CAP_INTERNAL_PORT)) 1099 adapter = rte_event_timer_adapter_create_ext(&conf, 1100 test_port_conf_cb, 1101 NULL); 1102 else 1103 adapter = rte_event_timer_adapter_create(&conf); 1104 TEST_ASSERT_NOT_NULL(adapter, "Failed to create adapter with valid " 1105 "configuration"); 1106 1107 /* Test existing id */ 1108 adapter2 = rte_event_timer_adapter_create(&conf); 1109 TEST_ASSERT_NULL(adapter2, "Created adapter with in-use id"); 1110 TEST_ASSERT(rte_errno == EEXIST, "Incorrect errno value for existing " 1111 "id"); 1112 1113 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapter), 1114 "Failed to free adapter"); 1115 1116 return TEST_SUCCESS; 1117 } 1118 1119 1120 /* Test that adapter can be freed correctly. */ 1121 static int 1122 adapter_free(void) 1123 { 1124 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 1125 "Failed to stop adapter"); 1126 1127 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 1128 "Failed to free valid adapter"); 1129 1130 /* Test free of already freed adapter */ 1131 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 1132 "Freed adapter that was already freed"); 1133 1134 /* Test free of null adapter */ 1135 timdev = NULL; 1136 TEST_ASSERT_FAIL(rte_event_timer_adapter_free(timdev), 1137 "Freed null adapter"); 1138 1139 rte_mempool_free(eventdev_test_mempool); 1140 1141 return TEST_SUCCESS; 1142 } 1143 1144 /* Test that adapter info can be retrieved and is correct. */ 1145 static int 1146 adapter_get_info(void) 1147 { 1148 struct rte_event_timer_adapter_info info; 1149 1150 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_get_info(timdev, &info), 1151 "Failed to get adapter info"); 1152 1153 if (using_services) 1154 TEST_ASSERT_EQUAL(info.event_dev_port_id, 1, 1155 "Expected port id = 1, got port id = %d", 1156 info.event_dev_port_id); 1157 1158 return TEST_SUCCESS; 1159 } 1160 1161 /* Test adapter lookup via adapter ID. */ 1162 static int 1163 adapter_lookup(void) 1164 { 1165 struct rte_event_timer_adapter *adapter; 1166 1167 adapter = rte_event_timer_adapter_lookup(TEST_ADAPTER_ID); 1168 TEST_ASSERT_NOT_NULL(adapter, "Failed to lookup adapter"); 1169 1170 return TEST_SUCCESS; 1171 } 1172 1173 static int 1174 adapter_start(void) 1175 { 1176 TEST_ASSERT_SUCCESS(_timdev_setup(180 * NSECPERSEC, NSECPERSEC / 10, 1177 RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES), 1178 "Failed to start adapter"); 1179 TEST_ASSERT_EQUAL(rte_event_timer_adapter_start(timdev), -EALREADY, 1180 "Timer adapter started without call to stop."); 1181 1182 return TEST_SUCCESS; 1183 } 1184 1185 /* Test that adapter stops correctly. */ 1186 static int 1187 adapter_stop(void) 1188 { 1189 struct rte_event_timer_adapter *l_adapter = NULL; 1190 1191 /* Test adapter stop */ 1192 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stop(timdev), 1193 "Failed to stop event adapter"); 1194 1195 TEST_ASSERT_FAIL(rte_event_timer_adapter_stop(l_adapter), 1196 "Erroneously stopped null event adapter"); 1197 1198 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(timdev), 1199 "Failed to free adapter"); 1200 1201 rte_mempool_free(eventdev_test_mempool); 1202 1203 return TEST_SUCCESS; 1204 } 1205 1206 /* Test increment and reset of ev_enq_count stat */ 1207 static int 1208 stat_inc_reset_ev_enq(void) 1209 { 1210 int ret, i, n; 1211 int num_evtims = MAX_TIMERS; 1212 struct rte_event_timer *evtims[num_evtims]; 1213 struct rte_event evs[BATCH_SIZE]; 1214 struct rte_event_timer_adapter_stats stats; 1215 const struct rte_event_timer init_tim = { 1216 .ev.op = RTE_EVENT_OP_NEW, 1217 .ev.queue_id = TEST_QUEUE_ID, 1218 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1219 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1220 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1221 .state = RTE_EVENT_TIMER_NOT_ARMED, 1222 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1223 }; 1224 1225 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1226 num_evtims); 1227 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1228 ret); 1229 1230 for (i = 0; i < num_evtims; i++) { 1231 *evtims[i] = init_tim; 1232 evtims[i]->ev.event_ptr = evtims[i]; 1233 } 1234 1235 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1236 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1237 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, "Stats not clear at " 1238 "startup"); 1239 1240 /* Test with the max value for the adapter */ 1241 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims); 1242 TEST_ASSERT_EQUAL(ret, num_evtims, 1243 "Failed to arm all event timers: attempted = %d, " 1244 "succeeded = %d, rte_errno = %s", 1245 num_evtims, ret, rte_strerror(rte_errno)); 1246 1247 rte_delay_ms(1000); 1248 1249 #define MAX_TRIES num_evtims 1250 int sum = 0; 1251 int tries = 0; 1252 bool done = false; 1253 while (!done) { 1254 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1255 RTE_DIM(evs), 10); 1256 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1257 done = true; 1258 1259 rte_delay_ms(10); 1260 } 1261 1262 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1263 "got %d", num_evtims, sum); 1264 1265 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1266 1267 rte_delay_ms(100); 1268 1269 /* Make sure the eventdev is still empty */ 1270 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1271 10); 1272 1273 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1274 "events from event device"); 1275 1276 /* Check stats again */ 1277 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1278 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1279 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, num_evtims, 1280 "Expected enqueue stat = %d; got %d", num_evtims, 1281 (int)stats.ev_enq_count); 1282 1283 /* Reset and check again */ 1284 ret = rte_event_timer_adapter_stats_reset(timdev); 1285 TEST_ASSERT_EQUAL(ret, 0, "Failed to reset stats"); 1286 1287 ret = rte_event_timer_adapter_stats_get(timdev, &stats); 1288 TEST_ASSERT_EQUAL(ret, 0, "Failed to get stats"); 1289 TEST_ASSERT_EQUAL((int)stats.ev_enq_count, 0, 1290 "Expected enqueue stat = %d; got %d", 0, 1291 (int)stats.ev_enq_count); 1292 1293 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1294 num_evtims); 1295 1296 return TEST_SUCCESS; 1297 } 1298 1299 /* Test various cases in arming timers */ 1300 static int 1301 event_timer_arm(void) 1302 { 1303 uint16_t n; 1304 int ret; 1305 struct rte_event_timer_adapter *adapter = timdev; 1306 struct rte_event_timer *evtim = NULL; 1307 struct rte_event evs[BATCH_SIZE]; 1308 const struct rte_event_timer init_tim = { 1309 .ev.op = RTE_EVENT_OP_NEW, 1310 .ev.queue_id = TEST_QUEUE_ID, 1311 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1312 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1313 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1314 .state = RTE_EVENT_TIMER_NOT_ARMED, 1315 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1316 }; 1317 1318 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1319 if (evtim == NULL) { 1320 /* Failed to get an event timer object */ 1321 return TEST_FAILED; 1322 } 1323 1324 /* Set up a timer */ 1325 *evtim = init_tim; 1326 evtim->ev.event_ptr = evtim; 1327 1328 /* Test single timer arm succeeds */ 1329 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1330 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1331 rte_strerror(rte_errno)); 1332 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event timer " 1333 "in incorrect state"); 1334 1335 /* Test arm of armed timer fails */ 1336 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1337 TEST_ASSERT_EQUAL(ret, 0, "expected return value from " 1338 "rte_event_timer_arm_burst: 0, got: %d", ret); 1339 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1340 "after arming already armed timer"); 1341 1342 /* Let timer expire */ 1343 rte_delay_ms(1000); 1344 1345 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1346 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1347 "events from event device"); 1348 1349 rte_mempool_put(eventdev_test_mempool, evtim); 1350 1351 return TEST_SUCCESS; 1352 } 1353 1354 /* This test checks that repeated references to the same event timer in the 1355 * arm request work as expected; only the first one through should succeed. 1356 */ 1357 static int 1358 event_timer_arm_double(void) 1359 { 1360 uint16_t n; 1361 int ret; 1362 struct rte_event_timer_adapter *adapter = timdev; 1363 struct rte_event_timer *evtim = NULL; 1364 struct rte_event evs[BATCH_SIZE]; 1365 const struct rte_event_timer init_tim = { 1366 .ev.op = RTE_EVENT_OP_NEW, 1367 .ev.queue_id = TEST_QUEUE_ID, 1368 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1369 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1370 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1371 .state = RTE_EVENT_TIMER_NOT_ARMED, 1372 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1373 }; 1374 1375 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1376 if (evtim == NULL) { 1377 /* Failed to get an event timer object */ 1378 return TEST_FAILED; 1379 } 1380 1381 /* Set up a timer */ 1382 *evtim = init_tim; 1383 evtim->ev.event_ptr = evtim; 1384 1385 struct rte_event_timer *evtim_arr[] = {evtim, evtim}; 1386 ret = rte_event_timer_arm_burst(adapter, evtim_arr, RTE_DIM(evtim_arr)); 1387 TEST_ASSERT_EQUAL(ret, 1, "Unexpected return value from " 1388 "rte_event_timer_arm_burst"); 1389 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1390 "after double-arm"); 1391 1392 /* Let timer expire */ 1393 rte_delay_ms(600); 1394 1395 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1396 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number of expiry events - " 1397 "expected: 1, actual: %d", n); 1398 1399 rte_mempool_put(eventdev_test_mempool, evtim); 1400 1401 return TEST_SUCCESS; 1402 } 1403 1404 /* Test the timer expiry event is generated at the expected time. */ 1405 static int 1406 event_timer_arm_expiry(void) 1407 { 1408 uint16_t n; 1409 int ret; 1410 struct rte_event_timer_adapter *adapter = timdev; 1411 struct rte_event_timer *evtim = NULL; 1412 struct rte_event_timer *evtim2 = NULL; 1413 struct rte_event evs[BATCH_SIZE]; 1414 const struct rte_event_timer init_tim = { 1415 .ev.op = RTE_EVENT_OP_NEW, 1416 .ev.queue_id = TEST_QUEUE_ID, 1417 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1418 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1419 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1420 .state = RTE_EVENT_TIMER_NOT_ARMED, 1421 }; 1422 1423 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1424 if (evtim == NULL) { 1425 /* Failed to get an event timer object */ 1426 return TEST_FAILED; 1427 } 1428 1429 /* Set up an event timer */ 1430 *evtim = init_tim; 1431 evtim->timeout_ticks = CALC_TICKS(30), // expire in 3 secs 1432 evtim->ev.event_ptr = evtim; 1433 1434 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1435 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s", 1436 rte_strerror(rte_errno)); 1437 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, "Event " 1438 "timer in incorrect state"); 1439 1440 rte_delay_ms(2999); 1441 1442 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1443 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event"); 1444 1445 /* Delay 100 ms to account for the adapter tick window - should let us 1446 * dequeue one event 1447 */ 1448 rte_delay_ms(100); 1449 1450 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1451 TEST_ASSERT_EQUAL(n, 1, "Dequeued incorrect number (%d) of timer " 1452 "expiry events", n); 1453 TEST_ASSERT_EQUAL(evs[0].event_type, RTE_EVENT_TYPE_TIMER, 1454 "Dequeued unexpected type of event"); 1455 1456 /* Check that we recover the original event timer and then free it */ 1457 evtim2 = evs[0].event_ptr; 1458 TEST_ASSERT_EQUAL(evtim, evtim2, 1459 "Failed to recover pointer to original event timer"); 1460 rte_mempool_put(eventdev_test_mempool, evtim2); 1461 1462 return TEST_SUCCESS; 1463 } 1464 1465 /* Check that rearming a timer works as expected. */ 1466 static int 1467 event_timer_arm_rearm(void) 1468 { 1469 uint16_t n; 1470 int ret; 1471 struct rte_event_timer *evtim = NULL; 1472 struct rte_event_timer *evtim2 = NULL; 1473 struct rte_event evs[BATCH_SIZE]; 1474 const struct rte_event_timer init_tim = { 1475 .ev.op = RTE_EVENT_OP_NEW, 1476 .ev.queue_id = TEST_QUEUE_ID, 1477 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1478 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1479 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1480 .state = RTE_EVENT_TIMER_NOT_ARMED, 1481 }; 1482 1483 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1484 if (evtim == NULL) { 1485 /* Failed to get an event timer object */ 1486 return TEST_FAILED; 1487 } 1488 1489 /* Set up a timer */ 1490 *evtim = init_tim; 1491 evtim->timeout_ticks = CALC_TICKS(1); // expire in 0.1 sec 1492 evtim->ev.event_ptr = evtim; 1493 1494 /* Arm it */ 1495 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1496 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1497 rte_strerror(rte_errno)); 1498 1499 /* Add 100ms to account for the adapter tick window */ 1500 rte_delay_ms(100 + 100); 1501 1502 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1503 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1504 "events from event device"); 1505 1506 /* Recover the timer through the event that was dequeued. */ 1507 evtim2 = evs[0].event_ptr; 1508 TEST_ASSERT_EQUAL(evtim, evtim2, 1509 "Failed to recover pointer to original event timer"); 1510 1511 /* Need to reset state in case implementation can't do it */ 1512 evtim2->state = RTE_EVENT_TIMER_NOT_ARMED; 1513 1514 /* Rearm it */ 1515 ret = rte_event_timer_arm_burst(timdev, &evtim2, 1); 1516 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1517 rte_strerror(rte_errno)); 1518 1519 /* Add 100ms to account for the adapter tick window */ 1520 rte_delay_ms(100 + 100); 1521 1522 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1523 TEST_ASSERT_EQUAL(n, 1, "Failed to dequeue expected number of expiry " 1524 "events from event device"); 1525 1526 /* Free it */ 1527 evtim2 = evs[0].event_ptr; 1528 TEST_ASSERT_EQUAL(evtim, evtim2, 1529 "Failed to recover pointer to original event timer"); 1530 rte_mempool_put(eventdev_test_mempool, evtim2); 1531 1532 return TEST_SUCCESS; 1533 } 1534 1535 /* Check that the adapter handles the max specified number of timers as 1536 * expected. 1537 */ 1538 static int 1539 event_timer_arm_max(void) 1540 { 1541 int ret, i, n; 1542 int num_evtims = MAX_TIMERS; 1543 struct rte_event_timer *evtims[num_evtims]; 1544 struct rte_event evs[BATCH_SIZE]; 1545 const struct rte_event_timer init_tim = { 1546 .ev.op = RTE_EVENT_OP_NEW, 1547 .ev.queue_id = TEST_QUEUE_ID, 1548 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1549 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1550 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1551 .state = RTE_EVENT_TIMER_NOT_ARMED, 1552 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1553 }; 1554 1555 ret = rte_mempool_get_bulk(eventdev_test_mempool, (void **)evtims, 1556 num_evtims); 1557 TEST_ASSERT_EQUAL(ret, 0, "Failed to get array of timer objs: ret = %d", 1558 ret); 1559 1560 for (i = 0; i < num_evtims; i++) { 1561 *evtims[i] = init_tim; 1562 evtims[i]->ev.event_ptr = evtims[i]; 1563 } 1564 1565 /* Test with the max value for the adapter */ 1566 ret = rte_event_timer_arm_burst(timdev, evtims, num_evtims); 1567 TEST_ASSERT_EQUAL(ret, num_evtims, 1568 "Failed to arm all event timers: attempted = %d, " 1569 "succeeded = %d, rte_errno = %s", 1570 num_evtims, ret, rte_strerror(rte_errno)); 1571 1572 rte_delay_ms(1000); 1573 1574 #define MAX_TRIES num_evtims 1575 int sum = 0; 1576 int tries = 0; 1577 bool done = false; 1578 while (!done) { 1579 sum += rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, 1580 RTE_DIM(evs), 10); 1581 if (sum >= num_evtims || ++tries >= MAX_TRIES) 1582 done = true; 1583 1584 rte_delay_ms(10); 1585 } 1586 1587 TEST_ASSERT_EQUAL(sum, num_evtims, "Expected %d timer expiry events, " 1588 "got %d", num_evtims, sum); 1589 1590 TEST_ASSERT(tries < MAX_TRIES, "Exceeded max tries"); 1591 1592 rte_delay_ms(100); 1593 1594 /* Make sure the eventdev is still empty */ 1595 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 1596 10); 1597 1598 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected number of timer expiry " 1599 "events from event device"); 1600 1601 rte_mempool_put_bulk(eventdev_test_mempool, (void **)evtims, 1602 num_evtims); 1603 1604 return TEST_SUCCESS; 1605 } 1606 1607 /* Check that creating an event timer with incorrect event sched type fails. */ 1608 static int 1609 event_timer_arm_invalid_sched_type(void) 1610 { 1611 int ret; 1612 struct rte_event_timer *evtim = NULL; 1613 const struct rte_event_timer init_tim = { 1614 .ev.op = RTE_EVENT_OP_NEW, 1615 .ev.queue_id = TEST_QUEUE_ID, 1616 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1617 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1618 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1619 .state = RTE_EVENT_TIMER_NOT_ARMED, 1620 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1621 }; 1622 1623 if (!using_services) 1624 return -ENOTSUP; 1625 1626 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1627 if (evtim == NULL) { 1628 /* Failed to get an event timer object */ 1629 return TEST_FAILED; 1630 } 1631 1632 *evtim = init_tim; 1633 evtim->ev.event_ptr = evtim; 1634 evtim->ev.sched_type = RTE_SCHED_TYPE_PARALLEL; // bad sched type 1635 1636 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1637 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1638 "sched type, but didn't"); 1639 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1640 " arm fail with invalid queue"); 1641 1642 rte_mempool_put(eventdev_test_mempool, &evtim); 1643 1644 return TEST_SUCCESS; 1645 } 1646 1647 /* Check that creating an event timer with a timeout value that is too small or 1648 * too big fails. 1649 */ 1650 static int 1651 event_timer_arm_invalid_timeout(void) 1652 { 1653 int ret; 1654 struct rte_event_timer *evtim = NULL; 1655 const struct rte_event_timer init_tim = { 1656 .ev.op = RTE_EVENT_OP_NEW, 1657 .ev.queue_id = TEST_QUEUE_ID, 1658 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1659 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1660 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1661 .state = RTE_EVENT_TIMER_NOT_ARMED, 1662 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1663 }; 1664 1665 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1666 if (evtim == NULL) { 1667 /* Failed to get an event timer object */ 1668 return TEST_FAILED; 1669 } 1670 1671 *evtim = init_tim; 1672 evtim->ev.event_ptr = evtim; 1673 evtim->timeout_ticks = 0; // timeout too small 1674 1675 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1676 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1677 "timeout, but didn't"); 1678 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1679 " arm fail with invalid timeout"); 1680 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOEARLY, 1681 "Unexpected event timer state"); 1682 1683 *evtim = init_tim; 1684 evtim->ev.event_ptr = evtim; 1685 evtim->timeout_ticks = CALC_TICKS(1801); // timeout too big 1686 1687 ret = rte_event_timer_arm_burst(timdev, &evtim, 1); 1688 TEST_ASSERT_EQUAL(ret, 0, "Expected to fail timer arm with invalid " 1689 "timeout, but didn't"); 1690 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after" 1691 " arm fail with invalid timeout"); 1692 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ERROR_TOOLATE, 1693 "Unexpected event timer state"); 1694 1695 rte_mempool_put(eventdev_test_mempool, evtim); 1696 1697 return TEST_SUCCESS; 1698 } 1699 1700 static int 1701 event_timer_cancel(void) 1702 { 1703 uint16_t n; 1704 int ret; 1705 struct rte_event_timer_adapter *adapter = timdev; 1706 struct rte_event_timer *evtim = NULL; 1707 struct rte_event evs[BATCH_SIZE]; 1708 const struct rte_event_timer init_tim = { 1709 .ev.op = RTE_EVENT_OP_NEW, 1710 .ev.queue_id = TEST_QUEUE_ID, 1711 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1712 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1713 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1714 .state = RTE_EVENT_TIMER_NOT_ARMED, 1715 }; 1716 1717 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1718 if (evtim == NULL) { 1719 /* Failed to get an event timer object */ 1720 return TEST_FAILED; 1721 } 1722 1723 /* Check that cancelling an uninited timer fails */ 1724 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1725 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling " 1726 "uninited timer"); 1727 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1728 "cancelling uninited timer"); 1729 1730 /* Set up a timer */ 1731 *evtim = init_tim; 1732 evtim->ev.event_ptr = evtim; 1733 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1734 1735 /* Check that cancelling an inited but unarmed timer fails */ 1736 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1737 TEST_ASSERT_EQUAL(ret, 0, "Succeeded unexpectedly in canceling " 1738 "unarmed timer"); 1739 TEST_ASSERT_EQUAL(rte_errno, EINVAL, "Unexpected rte_errno value after " 1740 "cancelling unarmed timer"); 1741 1742 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1743 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1744 rte_strerror(rte_errno)); 1745 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, 1746 "evtim in incorrect state"); 1747 1748 /* Delay 1 sec */ 1749 rte_delay_ms(1000); 1750 1751 ret = rte_event_timer_cancel_burst(adapter, &evtim, 1); 1752 TEST_ASSERT_EQUAL(ret, 1, "Failed to cancel event_timer: %s\n", 1753 rte_strerror(rte_errno)); 1754 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_CANCELED, 1755 "evtim in incorrect state"); 1756 1757 rte_delay_ms(3000); 1758 1759 /* Make sure that no expiry event was generated */ 1760 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1761 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n"); 1762 1763 rte_mempool_put(eventdev_test_mempool, evtim); 1764 1765 return TEST_SUCCESS; 1766 } 1767 1768 static int 1769 event_timer_cancel_double(void) 1770 { 1771 uint16_t n; 1772 int ret; 1773 struct rte_event_timer_adapter *adapter = timdev; 1774 struct rte_event_timer *evtim = NULL; 1775 struct rte_event evs[BATCH_SIZE]; 1776 const struct rte_event_timer init_tim = { 1777 .ev.op = RTE_EVENT_OP_NEW, 1778 .ev.queue_id = TEST_QUEUE_ID, 1779 .ev.sched_type = RTE_SCHED_TYPE_ATOMIC, 1780 .ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL, 1781 .ev.event_type = RTE_EVENT_TYPE_TIMER, 1782 .state = RTE_EVENT_TIMER_NOT_ARMED, 1783 .timeout_ticks = CALC_TICKS(5), // expire in .5 sec 1784 }; 1785 1786 rte_mempool_get(eventdev_test_mempool, (void **)&evtim); 1787 if (evtim == NULL) { 1788 /* Failed to get an event timer object */ 1789 return TEST_FAILED; 1790 } 1791 1792 /* Set up a timer */ 1793 *evtim = init_tim; 1794 evtim->ev.event_ptr = evtim; 1795 evtim->timeout_ticks = CALC_TICKS(30); // expire in 3 sec 1796 1797 ret = rte_event_timer_arm_burst(adapter, &evtim, 1); 1798 TEST_ASSERT_EQUAL(ret, 1, "Failed to arm event timer: %s\n", 1799 rte_strerror(rte_errno)); 1800 TEST_ASSERT_EQUAL(evtim->state, RTE_EVENT_TIMER_ARMED, 1801 "timer in unexpected state"); 1802 1803 /* Now, test that referencing the same timer twice in the same call 1804 * fails 1805 */ 1806 struct rte_event_timer *evtim_arr[] = {evtim, evtim}; 1807 ret = rte_event_timer_cancel_burst(adapter, evtim_arr, 1808 RTE_DIM(evtim_arr)); 1809 1810 /* Two requests to cancel same timer, only one should succeed */ 1811 TEST_ASSERT_EQUAL(ret, 1, "Succeeded unexpectedly in canceling timer " 1812 "twice"); 1813 1814 TEST_ASSERT_EQUAL(rte_errno, EALREADY, "Unexpected rte_errno value " 1815 "after double-cancel: rte_errno = %d", rte_errno); 1816 1817 rte_delay_ms(3000); 1818 1819 /* Still make sure that no expiry event was generated */ 1820 n = rte_event_dequeue_burst(evdev, TEST_PORT_ID, evs, RTE_DIM(evs), 0); 1821 TEST_ASSERT_EQUAL(n, 0, "Dequeued unexpected timer expiry event\n"); 1822 1823 rte_mempool_put(eventdev_test_mempool, evtim); 1824 1825 return TEST_SUCCESS; 1826 } 1827 1828 /* Check that event timer adapter tick resolution works as expected by testing 1829 * the number of adapter ticks that occur within a particular time interval. 1830 */ 1831 static int 1832 adapter_tick_resolution(void) 1833 { 1834 struct rte_event_timer_adapter_stats stats; 1835 uint64_t adapter_tick_count; 1836 1837 /* Only run this test in the software driver case */ 1838 if (!using_services) 1839 return -ENOTSUP; 1840 1841 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_reset(timdev), 1842 "Failed to reset stats"); 1843 1844 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev, 1845 &stats), "Failed to get adapter stats"); 1846 TEST_ASSERT_EQUAL(stats.adapter_tick_count, 0, "Adapter tick count " 1847 "not zeroed out"); 1848 1849 /* Delay 1 second; should let at least 10 ticks occur with the default 1850 * adapter configuration used by this test. 1851 */ 1852 rte_delay_ms(1000); 1853 1854 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_stats_get(timdev, 1855 &stats), "Failed to get adapter stats"); 1856 1857 adapter_tick_count = stats.adapter_tick_count; 1858 TEST_ASSERT(adapter_tick_count >= 10 && adapter_tick_count <= 12, 1859 "Expected 10-12 adapter ticks, got %"PRIu64"\n", 1860 adapter_tick_count); 1861 1862 return TEST_SUCCESS; 1863 } 1864 1865 static int 1866 adapter_create_max(void) 1867 { 1868 int i; 1869 uint32_t svc_start_count, svc_end_count; 1870 struct rte_event_timer_adapter *adapters[ 1871 RTE_EVENT_TIMER_ADAPTER_NUM_MAX + 1]; 1872 1873 struct rte_event_timer_adapter_conf conf = { 1874 .event_dev_id = evdev, 1875 // timer_adapter_id set in loop 1876 .clk_src = RTE_EVENT_TIMER_ADAPTER_CPU_CLK, 1877 .timer_tick_ns = NSECPERSEC / 10, 1878 .max_tmo_ns = 180 * NSECPERSEC, 1879 .nb_timers = MAX_TIMERS, 1880 .flags = RTE_EVENT_TIMER_ADAPTER_F_ADJUST_RES, 1881 }; 1882 1883 if (!using_services) 1884 return -ENOTSUP; 1885 1886 svc_start_count = rte_service_get_count(); 1887 1888 /* This test expects that there are sufficient service IDs available 1889 * to be allocated. I.e., RTE_EVENT_TIMER_ADAPTER_NUM_MAX may need to 1890 * be less than RTE_SERVICE_NUM_MAX if anything else uses a service 1891 * (the SW event device, for example). 1892 */ 1893 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) { 1894 conf.timer_adapter_id = i; 1895 adapters[i] = rte_event_timer_adapter_create_ext(&conf, 1896 test_port_conf_cb, NULL); 1897 TEST_ASSERT_NOT_NULL(adapters[i], "Failed to create adapter " 1898 "%d", i); 1899 } 1900 1901 conf.timer_adapter_id = i; 1902 adapters[i] = rte_event_timer_adapter_create(&conf); 1903 TEST_ASSERT_NULL(adapters[i], "Created too many adapters"); 1904 1905 /* Check that at least RTE_EVENT_TIMER_ADAPTER_NUM_MAX services 1906 * have been created 1907 */ 1908 svc_end_count = rte_service_get_count(); 1909 TEST_ASSERT_EQUAL(svc_end_count - svc_start_count, 1910 RTE_EVENT_TIMER_ADAPTER_NUM_MAX, 1911 "Failed to create expected number of services"); 1912 1913 for (i = 0; i < RTE_EVENT_TIMER_ADAPTER_NUM_MAX; i++) 1914 TEST_ASSERT_SUCCESS(rte_event_timer_adapter_free(adapters[i]), 1915 "Failed to free adapter %d", i); 1916 1917 /* Check that service count is back to where it was at start */ 1918 svc_end_count = rte_service_get_count(); 1919 TEST_ASSERT_EQUAL(svc_start_count, svc_end_count, "Failed to release " 1920 "correct number of services"); 1921 1922 return TEST_SUCCESS; 1923 } 1924 1925 static struct unit_test_suite event_timer_adptr_functional_testsuite = { 1926 .suite_name = "event timer functional test suite", 1927 .setup = testsuite_setup, 1928 .teardown = testsuite_teardown, 1929 .unit_test_cases = { 1930 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1931 test_timer_state), 1932 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1933 test_timer_arm), 1934 TEST_CASE_ST(timdev_setup_msec_periodic, timdev_teardown, 1935 test_timer_arm_periodic), 1936 TEST_CASE_ST(timdev_setup_usec, timdev_teardown, 1937 test_timer_arm_burst), 1938 TEST_CASE_ST(timdev_setup_msec_periodic, timdev_teardown, 1939 test_timer_arm_burst_periodic), 1940 TEST_CASE_ST(timdev_setup_sec, timdev_teardown, 1941 test_timer_cancel), 1942 TEST_CASE_ST(timdev_setup_sec_periodic, timdev_teardown, 1943 test_timer_cancel_periodic), 1944 TEST_CASE_ST(timdev_setup_sec, timdev_teardown, 1945 test_timer_cancel_random), 1946 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown, 1947 test_timer_arm_multicore), 1948 TEST_CASE_ST(timdev_setup_usec_multicore, timdev_teardown, 1949 test_timer_arm_burst_multicore), 1950 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown, 1951 test_timer_cancel_multicore), 1952 TEST_CASE_ST(timdev_setup_sec_multicore, timdev_teardown, 1953 test_timer_cancel_burst_multicore), 1954 TEST_CASE(adapter_create), 1955 TEST_CASE_ST(timdev_setup_msec, NULL, adapter_free), 1956 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1957 adapter_get_info), 1958 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1959 adapter_lookup), 1960 TEST_CASE_ST(NULL, timdev_teardown, 1961 adapter_start), 1962 TEST_CASE_ST(timdev_setup_msec, NULL, 1963 adapter_stop), 1964 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1965 stat_inc_reset_ev_enq), 1966 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1967 event_timer_arm), 1968 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1969 event_timer_arm_double), 1970 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1971 event_timer_arm_expiry), 1972 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1973 event_timer_arm_rearm), 1974 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1975 event_timer_arm_max), 1976 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1977 event_timer_arm_invalid_sched_type), 1978 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1979 event_timer_arm_invalid_timeout), 1980 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1981 event_timer_cancel), 1982 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1983 event_timer_cancel_double), 1984 TEST_CASE_ST(timdev_setup_msec, timdev_teardown, 1985 adapter_tick_resolution), 1986 TEST_CASE(adapter_create_max), 1987 TEST_CASES_END() /**< NULL terminate unit test array */ 1988 } 1989 }; 1990 1991 static int 1992 test_event_timer_adapter_func(void) 1993 { 1994 return unit_test_suite_runner(&event_timer_adptr_functional_testsuite); 1995 } 1996 1997 #endif /* !RTE_EXEC_ENV_WINDOWS */ 1998 1999 REGISTER_TEST_COMMAND(event_timer_adapter_test, test_event_timer_adapter_func); 2000