app/test/test_event_timer_adapter.c

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