LCOV - code coverage report
Current view: top level - app/test - test_eventdev.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 398 532 74.8 %
Date: 2024-01-22 15:35:40 Functions: 52 57 91.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 194 490 39.6 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2016 Cavium, Inc
       3                 :            :  */
       4                 :            : 
       5                 :            : #include "test.h"
       6                 :            : 
       7                 :            : #include <rte_common.h>
       8                 :            : #include <rte_hexdump.h>
       9                 :            : #include <rte_mbuf.h>
      10                 :            : #include <rte_malloc.h>
      11                 :            : #include <rte_memcpy.h>
      12                 :            : 
      13                 :            : #ifdef RTE_EXEC_ENV_WINDOWS
      14                 :            : static int
      15                 :            : test_eventdev_common(void)
      16                 :            : {
      17                 :            :         printf("eventdev_common not supported on Windows, skipping test\n");
      18                 :            :         return TEST_SKIPPED;
      19                 :            : }
      20                 :            : 
      21                 :            : #else
      22                 :            : 
      23                 :            : #include <rte_eventdev.h>
      24                 :            : #include <rte_dev.h>
      25                 :            : #include <rte_bus_vdev.h>
      26                 :            : 
      27                 :            : #define TEST_DEV_ID   0
      28                 :            : 
      29                 :            : static int
      30                 :          1 : testsuite_setup(void)
      31                 :            : {
      32                 :            :         RTE_BUILD_BUG_ON(sizeof(struct rte_event) != 16);
      33                 :            :         uint8_t count;
      34                 :          1 :         count = rte_event_dev_count();
      35         [ +  - ]:          1 :         if (!count) {
      36                 :            :                 printf("Failed to find a valid event device,"
      37                 :            :                         " testing with event_skeleton device\n");
      38                 :          1 :                 return rte_vdev_init("event_skeleton", NULL);
      39                 :            :         }
      40                 :            :         return TEST_SUCCESS;
      41                 :            : }
      42                 :            : 
      43                 :            : static void
      44                 :          1 : testsuite_teardown(void)
      45                 :            : {
      46                 :          1 : }
      47                 :            : 
      48                 :            : static int
      49                 :          1 : test_eventdev_count(void)
      50                 :            : {
      51                 :            :         uint8_t count;
      52                 :          1 :         count = rte_event_dev_count();
      53         [ -  + ]:          1 :         TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count);
      54                 :            :         return TEST_SUCCESS;
      55                 :            : }
      56                 :            : 
      57                 :            : static int
      58                 :          1 : test_eventdev_get_dev_id(void)
      59                 :            : {
      60                 :            :         int ret;
      61                 :          1 :         ret = rte_event_dev_get_dev_id("not_a_valid_eventdev_driver");
      62         [ -  + ]:          1 :         TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret);
      63                 :            :         return TEST_SUCCESS;
      64                 :            : }
      65                 :            : 
      66                 :            : static int
      67                 :          1 : test_eventdev_socket_id(void)
      68                 :            : {
      69                 :            :         int socket_id;
      70                 :          1 :         socket_id = rte_event_dev_socket_id(TEST_DEV_ID);
      71         [ -  + ]:          1 :         TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d",
      72                 :            :                                 socket_id);
      73                 :          1 :         socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS);
      74         [ -  + ]:          1 :         TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id);
      75                 :            : 
      76                 :            :         return TEST_SUCCESS;
      77                 :            : }
      78                 :            : 
      79                 :            : static int
      80                 :          1 : test_eventdev_info_get(void)
      81                 :            : {
      82                 :            :         int ret;
      83                 :            :         struct rte_event_dev_info info;
      84                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, NULL);
      85         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
      86                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
      87         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
      88         [ -  + ]:          1 :         TEST_ASSERT(info.max_event_ports > 0,
      89                 :            :                         "Not enough event ports %d", info.max_event_ports);
      90         [ -  + ]:          1 :         TEST_ASSERT(info.max_event_queues > 0,
      91                 :            :                         "Not enough event queues %d", info.max_event_queues);
      92                 :            :         return TEST_SUCCESS;
      93                 :            : }
      94                 :            : 
      95                 :            : static inline void
      96                 :         33 : devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf,
      97                 :            :                         struct rte_event_dev_info *info)
      98                 :            : {
      99                 :            :         memset(dev_conf, 0, sizeof(struct rte_event_dev_config));
     100                 :         33 :         dev_conf->dequeue_timeout_ns = info->min_dequeue_timeout_ns;
     101                 :         33 :         dev_conf->nb_event_ports = info->max_event_ports;
     102                 :         33 :         dev_conf->nb_event_queues = info->max_event_queues;
     103                 :         33 :         dev_conf->nb_event_queue_flows = info->max_event_queue_flows;
     104                 :         33 :         dev_conf->nb_event_port_dequeue_depth =
     105                 :         33 :                         info->max_event_port_dequeue_depth;
     106                 :         33 :         dev_conf->nb_event_port_enqueue_depth =
     107                 :         33 :                         info->max_event_port_enqueue_depth;
     108                 :            :         dev_conf->nb_event_port_enqueue_depth =
     109                 :            :                         info->max_event_port_enqueue_depth;
     110                 :         33 :         dev_conf->nb_events_limit =
     111                 :         33 :                         info->max_num_events;
     112                 :         33 : }
     113                 :            : 
     114                 :            : static int
     115                 :          7 : test_ethdev_config_run(struct rte_event_dev_config *dev_conf,
     116                 :            :                 struct rte_event_dev_info *info,
     117                 :            :                 void (*fn)(struct rte_event_dev_config *dev_conf,
     118                 :            :                         struct rte_event_dev_info *info))
     119                 :            : {
     120                 :          7 :         devconf_set_default_sane_values(dev_conf, info);
     121                 :          7 :         fn(dev_conf, info);
     122                 :          7 :         return rte_event_dev_configure(TEST_DEV_ID, dev_conf);
     123                 :            : }
     124                 :            : 
     125                 :            : static void
     126                 :          1 : max_dequeue_limit(struct rte_event_dev_config *dev_conf,
     127                 :            :                   struct rte_event_dev_info *info)
     128                 :            : {
     129                 :          1 :         dev_conf->dequeue_timeout_ns = info->max_dequeue_timeout_ns + 1;
     130                 :          1 : }
     131                 :            : 
     132                 :            : static void
     133                 :          1 : max_events_limit(struct rte_event_dev_config *dev_conf,
     134                 :            :                   struct rte_event_dev_info *info)
     135                 :            : {
     136                 :          1 :         dev_conf->nb_events_limit  = info->max_num_events + 1;
     137                 :          1 : }
     138                 :            : 
     139                 :            : static void
     140                 :          1 : max_event_ports(struct rte_event_dev_config *dev_conf,
     141                 :            :                   struct rte_event_dev_info *info)
     142                 :            : {
     143                 :          1 :         dev_conf->nb_event_ports = info->max_event_ports + 1;
     144                 :          1 : }
     145                 :            : 
     146                 :            : static void
     147                 :          1 : max_event_queues(struct rte_event_dev_config *dev_conf,
     148                 :            :                   struct rte_event_dev_info *info)
     149                 :            : {
     150                 :          1 :         dev_conf->nb_event_queues = info->max_event_queues + 1;
     151                 :          1 : }
     152                 :            : 
     153                 :            : static void
     154                 :          1 : max_event_queue_flows(struct rte_event_dev_config *dev_conf,
     155                 :            :                   struct rte_event_dev_info *info)
     156                 :            : {
     157                 :          1 :         dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1;
     158                 :          1 : }
     159                 :            : 
     160                 :            : static void
     161                 :          1 : max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf,
     162                 :            :                   struct rte_event_dev_info *info)
     163                 :            : {
     164                 :          1 :         dev_conf->nb_event_port_dequeue_depth =
     165                 :          1 :                 info->max_event_port_dequeue_depth + 1;
     166                 :          1 : }
     167                 :            : 
     168                 :            : static void
     169                 :          1 : max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf,
     170                 :            :                   struct rte_event_dev_info *info)
     171                 :            : {
     172                 :          1 :         dev_conf->nb_event_port_enqueue_depth =
     173                 :          1 :                 info->max_event_port_enqueue_depth + 1;
     174                 :          1 : }
     175                 :            : 
     176                 :            : 
     177                 :            : static int
     178                 :          1 : test_eventdev_configure(void)
     179                 :            : {
     180                 :            :         int ret;
     181                 :            :         struct rte_event_dev_config dev_conf;
     182                 :            :         struct rte_event_dev_info info;
     183                 :          1 :         ret = rte_event_dev_configure(TEST_DEV_ID, NULL);
     184         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     185                 :            : 
     186                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     187         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     188                 :            : 
     189                 :            :         /* Check limits */
     190         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(-EINVAL,
     191                 :            :                 test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit),
     192                 :            :                  "Config negative test failed");
     193         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(-EINVAL,
     194                 :            :                 test_ethdev_config_run(&dev_conf, &info, max_events_limit),
     195                 :            :                  "Config negative test failed");
     196         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(-EINVAL,
     197                 :            :                 test_ethdev_config_run(&dev_conf, &info, max_event_ports),
     198                 :            :                  "Config negative test failed");
     199         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(-EINVAL,
     200                 :            :                 test_ethdev_config_run(&dev_conf, &info, max_event_queues),
     201                 :            :                  "Config negative test failed");
     202         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(-EINVAL,
     203                 :            :                 test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows),
     204                 :            :                 "Config negative test failed");
     205                 :            : 
     206         [ +  - ]:          1 :         if (info.event_dev_cap & RTE_EVENT_DEV_CAP_BURST_MODE) {
     207         [ -  + ]:          1 :                 TEST_ASSERT_EQUAL(-EINVAL,
     208                 :            :                                 test_ethdev_config_run(&dev_conf, &info,
     209                 :            :                                         max_event_port_dequeue_depth),
     210                 :            :                                 "Config negative test failed");
     211         [ -  + ]:          1 :                 TEST_ASSERT_EQUAL(-EINVAL,
     212                 :            :                                 test_ethdev_config_run(&dev_conf, &info,
     213                 :            :                                         max_event_port_enqueue_depth),
     214                 :            :                                 "Config negative test failed");
     215                 :            :         }
     216                 :            : 
     217                 :            :         /* Positive case */
     218                 :          1 :         devconf_set_default_sane_values(&dev_conf, &info);
     219                 :          1 :         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
     220         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
     221                 :            : 
     222                 :            :         /* re-configure */
     223                 :          1 :         devconf_set_default_sane_values(&dev_conf, &info);
     224                 :          1 :         dev_conf.nb_event_ports = RTE_MAX(info.max_event_ports/2, 1);
     225                 :          1 :         dev_conf.nb_event_queues = RTE_MAX(info.max_event_queues/2, 1);
     226                 :          1 :         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
     227         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev");
     228                 :            : 
     229                 :            :         /* re-configure back to max_event_queues and max_event_ports */
     230                 :          1 :         devconf_set_default_sane_values(&dev_conf, &info);
     231                 :          1 :         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
     232         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev");
     233                 :            : 
     234                 :            :         return TEST_SUCCESS;
     235                 :            : 
     236                 :            : }
     237                 :            : 
     238                 :            : static int
     239                 :         23 : eventdev_configure_setup(void)
     240                 :            : {
     241                 :            :         int ret;
     242                 :            :         struct rte_event_dev_config dev_conf;
     243                 :            :         struct rte_event_dev_info info;
     244                 :            : 
     245                 :         23 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     246         [ -  + ]:         23 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     247                 :         23 :         devconf_set_default_sane_values(&dev_conf, &info);
     248                 :         23 :         ret = rte_event_dev_configure(TEST_DEV_ID, &dev_conf);
     249         [ -  + ]:         23 :         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
     250                 :            : 
     251                 :            :         return TEST_SUCCESS;
     252                 :            : }
     253                 :            : 
     254                 :            : static int
     255                 :          1 : test_eventdev_queue_default_conf_get(void)
     256                 :            : {
     257                 :            :         int i, ret;
     258                 :            :         struct rte_event_queue_conf qconf;
     259                 :            : 
     260                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, NULL);
     261         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     262                 :            : 
     263                 :            :         uint32_t queue_count;
     264         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     265                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     266                 :            :                             "Queue count get failed");
     267                 :            : 
     268         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     269                 :         64 :                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
     270                 :            :                                                  &qconf);
     271         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i);
     272                 :            :         }
     273                 :            : 
     274                 :            :         return TEST_SUCCESS;
     275                 :            : }
     276                 :            : 
     277                 :            : static int
     278                 :          1 : test_eventdev_queue_setup(void)
     279                 :            : {
     280                 :            :         int i, ret;
     281                 :            :         struct rte_event_dev_info info;
     282                 :            :         struct rte_event_queue_conf qconf;
     283                 :            : 
     284                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     285         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     286                 :            : 
     287                 :            :         /* Negative cases */
     288                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
     289         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
     290                 :          1 :         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_ALL_TYPES;
     291                 :          1 :         qconf.nb_atomic_flows = info.max_event_queue_flows + 1;
     292                 :          1 :         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
     293         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     294                 :            : 
     295                 :          1 :         qconf.nb_atomic_flows = info.max_event_queue_flows;
     296                 :          1 :         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
     297                 :          1 :         qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1;
     298                 :          1 :         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
     299         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     300                 :            : 
     301                 :          1 :         ret = rte_event_queue_setup(TEST_DEV_ID, info.max_event_queues,
     302                 :            :                                         &qconf);
     303         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     304                 :            : 
     305                 :            :         /* Positive case */
     306                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
     307         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info");
     308                 :          1 :         ret = rte_event_queue_setup(TEST_DEV_ID, 0, &qconf);
     309         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0");
     310                 :            : 
     311                 :            :         uint32_t queue_count;
     312         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     313                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     314                 :            :                             "Queue count get failed");
     315                 :            : 
     316         [ +  + ]:         64 :         for (i = 1; i < (int)queue_count; i++) {
     317                 :         63 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
     318         [ -  + ]:         63 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     319                 :            :         }
     320                 :            : 
     321                 :            :         return TEST_SUCCESS;
     322                 :            : }
     323                 :            : 
     324                 :            : static int
     325                 :          1 : test_eventdev_queue_count(void)
     326                 :            : {
     327                 :            :         int ret;
     328                 :            :         struct rte_event_dev_info info;
     329                 :            : 
     330                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     331         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     332                 :            : 
     333                 :            :         uint32_t queue_count;
     334         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     335                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     336                 :            :                             "Queue count get failed");
     337         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(queue_count, info.max_event_queues,
     338                 :            :                           "Wrong queue count");
     339                 :            : 
     340                 :            :         return TEST_SUCCESS;
     341                 :            : }
     342                 :            : 
     343                 :            : static int
     344                 :          1 : test_eventdev_queue_attr_priority(void)
     345                 :            : {
     346                 :            :         int i, ret;
     347                 :            :         struct rte_event_dev_info info;
     348                 :            :         struct rte_event_queue_conf qconf;
     349                 :            :         uint8_t priority;
     350                 :            : 
     351                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     352         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     353                 :            : 
     354                 :            :         uint32_t queue_count;
     355         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     356                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     357                 :            :                             "Queue count get failed");
     358                 :            : 
     359         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     360                 :         64 :                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i,
     361                 :            :                                         &qconf);
     362         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
     363                 :         64 :                 qconf.priority = i %  RTE_EVENT_DEV_PRIORITY_LOWEST;
     364                 :         64 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     365         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     366                 :            :         }
     367                 :            : 
     368         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     369                 :            :                 uint32_t tmp;
     370         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
     371                 :            :                                     RTE_EVENT_QUEUE_ATTR_PRIORITY, &tmp),
     372                 :            :                                     "Queue priority get failed");
     373                 :         64 :                 priority = tmp;
     374                 :            : 
     375         [ +  - ]:         64 :                 if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS)
     376         [ -  + ]:         64 :                         TEST_ASSERT_EQUAL(priority,
     377                 :            :                          i %  RTE_EVENT_DEV_PRIORITY_LOWEST,
     378                 :            :                          "Wrong priority value for queue%d", i);
     379                 :            :                 else
     380         [ #  # ]:          0 :                         TEST_ASSERT_EQUAL(priority,
     381                 :            :                          RTE_EVENT_DEV_PRIORITY_NORMAL,
     382                 :            :                          "Wrong priority value for queue%d", i);
     383                 :            :         }
     384                 :            : 
     385                 :            :         return TEST_SUCCESS;
     386                 :            : }
     387                 :            : 
     388                 :            : static int
     389                 :          1 : test_eventdev_queue_attr_priority_runtime(void)
     390                 :            : {
     391                 :            :         uint32_t queue_count, queue_req, prio, deq_cnt;
     392                 :            :         struct rte_event_queue_conf qconf;
     393                 :            :         struct rte_event_port_conf pconf;
     394                 :            :         struct rte_event_dev_info info;
     395                 :          1 :         struct rte_event event = {
     396                 :            :                 .op = RTE_EVENT_OP_NEW,
     397                 :            :                 .event_type = RTE_EVENT_TYPE_CPU,
     398                 :            :                 .sched_type = RTE_SCHED_TYPE_ATOMIC,
     399                 :            :                 .u64 = 0xbadbadba,
     400                 :            :         };
     401                 :            :         int i, ret;
     402                 :            : 
     403                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     404         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     405                 :            : 
     406         [ -  + ]:          1 :         if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
     407                 :            :                 return TEST_SKIPPED;
     408                 :            : 
     409         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
     410                 :            :                                     TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
     411                 :            :                                     &queue_count),
     412                 :            :                             "Queue count get failed");
     413                 :            : 
     414                 :            :         /* Need at least 2 queues to test LOW and HIGH priority. */
     415         [ #  # ]:          0 :         TEST_ASSERT(queue_count > 1, "Not enough event queues, needed 2");
     416                 :            :         queue_req = 2;
     417                 :            : 
     418         [ #  # ]:          0 :         for (i = 0; i < (int)queue_count; i++) {
     419                 :          0 :                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
     420         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
     421                 :          0 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     422         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     423                 :            :         }
     424                 :            : 
     425                 :          0 :         ret = rte_event_queue_attr_set(TEST_DEV_ID, 0,
     426                 :            :                                        RTE_EVENT_QUEUE_ATTR_PRIORITY,
     427                 :            :                                        RTE_EVENT_DEV_PRIORITY_LOWEST);
     428         [ #  # ]:          0 :         if (ret == -ENOTSUP)
     429                 :            :                 return TEST_SKIPPED;
     430         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(ret, "Queue0 priority set failed");
     431                 :            : 
     432                 :          0 :         ret = rte_event_queue_attr_set(TEST_DEV_ID, 1,
     433                 :            :                                        RTE_EVENT_QUEUE_ATTR_PRIORITY,
     434                 :            :                                        RTE_EVENT_DEV_PRIORITY_HIGHEST);
     435         [ #  # ]:          0 :         if (ret == -ENOTSUP)
     436                 :            :                 return TEST_SKIPPED;
     437         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(ret, "Queue1 priority set failed");
     438                 :            : 
     439                 :            :         /* Setup event port 0 */
     440                 :          0 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     441         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     442                 :          0 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     443         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
     444                 :          0 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
     445         [ #  # ]:          0 :         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
     446                 :            :                     TEST_DEV_ID);
     447                 :            : 
     448                 :          0 :         ret = rte_event_dev_start(TEST_DEV_ID);
     449         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
     450                 :            : 
     451         [ #  # ]:          0 :         for (i = 0; i < (int)queue_req; i++) {
     452                 :          0 :                 event.queue_id = i;
     453         [ #  # ]:          0 :                 while (rte_event_enqueue_burst(TEST_DEV_ID, 0, &event, 1) != 1)
     454                 :            :                         rte_pause();
     455                 :            :         }
     456                 :            : 
     457                 :            :         prio = RTE_EVENT_DEV_PRIORITY_HIGHEST;
     458                 :            :         deq_cnt = 0;
     459         [ #  # ]:          0 :         while (deq_cnt < queue_req) {
     460                 :            :                 uint32_t queue_prio;
     461                 :            : 
     462         [ #  # ]:          0 :                 if (rte_event_dequeue_burst(TEST_DEV_ID, 0, &event, 1, 0) == 0)
     463                 :          0 :                         continue;
     464                 :            : 
     465                 :          0 :                 ret = rte_event_queue_attr_get(TEST_DEV_ID, event.queue_id,
     466                 :            :                                                RTE_EVENT_QUEUE_ATTR_PRIORITY,
     467                 :            :                                                &queue_prio);
     468         [ #  # ]:          0 :                 if (ret == -ENOTSUP)
     469                 :          0 :                         return TEST_SKIPPED;
     470                 :            : 
     471         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Queue priority get failed");
     472         [ #  # ]:          0 :                 TEST_ASSERT(queue_prio >= prio,
     473                 :            :                             "Received event from a lower priority queue first");
     474                 :            :                 prio = queue_prio;
     475                 :          0 :                 deq_cnt++;
     476                 :            :         }
     477                 :            : 
     478                 :            :         return TEST_SUCCESS;
     479                 :            : }
     480                 :            : 
     481                 :            : static int
     482                 :          1 : test_eventdev_queue_attr_weight_runtime(void)
     483                 :            : {
     484                 :            :         struct rte_event_queue_conf qconf;
     485                 :            :         struct rte_event_dev_info info;
     486                 :            :         uint32_t queue_count;
     487                 :            :         int i, ret;
     488                 :            : 
     489                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     490         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     491                 :            : 
     492         [ -  + ]:          1 :         if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
     493                 :            :                 return TEST_SKIPPED;
     494                 :            : 
     495         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
     496                 :            :                                     TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
     497                 :            :                                     &queue_count),
     498                 :            :                             "Queue count get failed");
     499                 :            : 
     500         [ #  # ]:          0 :         for (i = 0; i < (int)queue_count; i++) {
     501                 :          0 :                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
     502         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
     503                 :          0 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     504         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     505                 :            :         }
     506                 :            : 
     507         [ #  # ]:          0 :         for (i = 0; i < (int)queue_count; i++) {
     508                 :            :                 uint32_t get_val;
     509                 :            :                 uint64_t set_val;
     510                 :            : 
     511                 :          0 :                 set_val = i % RTE_EVENT_QUEUE_WEIGHT_HIGHEST;
     512                 :          0 :                 ret = rte_event_queue_attr_set(
     513                 :            :                         TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_WEIGHT, set_val);
     514         [ #  # ]:          0 :                 if (ret == -ENOTSUP)
     515                 :          0 :                         return TEST_SKIPPED;
     516                 :            : 
     517         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Queue weight set failed");
     518                 :            : 
     519                 :          0 :                 ret = rte_event_queue_attr_get(
     520                 :            :                         TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_WEIGHT, &get_val);
     521         [ #  # ]:          0 :                 if (ret == -ENOTSUP)
     522                 :            :                         return TEST_SKIPPED;
     523                 :            : 
     524         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Queue weight get failed");
     525         [ #  # ]:          0 :                 TEST_ASSERT_EQUAL(get_val, set_val,
     526                 :            :                                   "Wrong weight value for queue%d", i);
     527                 :            :         }
     528                 :            : 
     529                 :            :         return TEST_SUCCESS;
     530                 :            : }
     531                 :            : 
     532                 :            : static int
     533                 :          1 : test_eventdev_queue_attr_affinity_runtime(void)
     534                 :            : {
     535                 :            :         struct rte_event_queue_conf qconf;
     536                 :            :         struct rte_event_dev_info info;
     537                 :            :         uint32_t queue_count;
     538                 :            :         int i, ret;
     539                 :            : 
     540                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     541         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     542                 :            : 
     543         [ -  + ]:          1 :         if (!(info.event_dev_cap & RTE_EVENT_DEV_CAP_RUNTIME_QUEUE_ATTR))
     544                 :            :                 return TEST_SKIPPED;
     545                 :            : 
     546         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(
     547                 :            :                                     TEST_DEV_ID, RTE_EVENT_DEV_ATTR_QUEUE_COUNT,
     548                 :            :                                     &queue_count),
     549                 :            :                             "Queue count get failed");
     550                 :            : 
     551         [ #  # ]:          0 :         for (i = 0; i < (int)queue_count; i++) {
     552                 :          0 :                 ret = rte_event_queue_default_conf_get(TEST_DEV_ID, i, &qconf);
     553         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i);
     554                 :          0 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     555         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     556                 :            :         }
     557                 :            : 
     558         [ #  # ]:          0 :         for (i = 0; i < (int)queue_count; i++) {
     559                 :            :                 uint32_t get_val;
     560                 :            :                 uint64_t set_val;
     561                 :            : 
     562                 :          0 :                 set_val = i % RTE_EVENT_QUEUE_AFFINITY_HIGHEST;
     563                 :          0 :                 ret = rte_event_queue_attr_set(
     564                 :            :                         TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_AFFINITY, set_val);
     565         [ #  # ]:          0 :                 if (ret == -ENOTSUP)
     566                 :          0 :                         return TEST_SKIPPED;
     567                 :            : 
     568         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Queue affinity set failed");
     569                 :            : 
     570                 :          0 :                 ret = rte_event_queue_attr_get(
     571                 :            :                         TEST_DEV_ID, i, RTE_EVENT_QUEUE_ATTR_AFFINITY, &get_val);
     572         [ #  # ]:          0 :                 if (ret == -ENOTSUP)
     573                 :            :                         return TEST_SKIPPED;
     574                 :            : 
     575         [ #  # ]:          0 :                 TEST_ASSERT_SUCCESS(ret, "Queue affinity get failed");
     576         [ #  # ]:          0 :                 TEST_ASSERT_EQUAL(get_val, set_val,
     577                 :            :                                   "Wrong affinity value for queue%d", i);
     578                 :            :         }
     579                 :            : 
     580                 :            :         return TEST_SUCCESS;
     581                 :            : }
     582                 :            : 
     583                 :            : static int
     584                 :          1 : test_eventdev_queue_attr_nb_atomic_flows(void)
     585                 :            : {
     586                 :            :         int i, ret;
     587                 :            :         struct rte_event_dev_info info;
     588                 :            :         struct rte_event_queue_conf qconf;
     589                 :            :         uint32_t nb_atomic_flows;
     590                 :            : 
     591                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     592         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     593                 :            : 
     594                 :            :         uint32_t queue_count;
     595         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     596                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     597                 :            :                             "Queue count get failed");
     598                 :            : 
     599                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
     600         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
     601                 :            : 
     602         [ +  - ]:          1 :         if (qconf.nb_atomic_flows == 0)
     603                 :            :                 /* Assume PMD doesn't support atomic flows, return early */
     604                 :            :                 return -ENOTSUP;
     605                 :            : 
     606                 :          1 :         qconf.schedule_type = RTE_SCHED_TYPE_ATOMIC;
     607                 :            : 
     608         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     609                 :         64 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     610         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     611                 :            :         }
     612                 :            : 
     613         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     614         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
     615                 :            :                                     RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_FLOWS,
     616                 :            :                                     &nb_atomic_flows),
     617                 :            :                                     "Queue nb_atomic_flows get failed");
     618                 :            : 
     619         [ -  + ]:         64 :                 TEST_ASSERT_EQUAL(nb_atomic_flows, qconf.nb_atomic_flows,
     620                 :            :                                   "Wrong atomic flows value for queue%d", i);
     621                 :            :         }
     622                 :            : 
     623                 :            :         return TEST_SUCCESS;
     624                 :            : }
     625                 :            : 
     626                 :            : static int
     627                 :          1 : test_eventdev_queue_attr_nb_atomic_order_sequences(void)
     628                 :            : {
     629                 :            :         int i, ret;
     630                 :            :         struct rte_event_dev_info info;
     631                 :            :         struct rte_event_queue_conf qconf;
     632                 :            :         uint32_t nb_atomic_order_sequences;
     633                 :            : 
     634                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     635         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     636                 :            : 
     637                 :            :         uint32_t queue_count;
     638         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     639                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     640                 :            :                             "Queue count get failed");
     641                 :            : 
     642                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
     643         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get queue 0's def conf");
     644                 :            : 
     645         [ +  - ]:          1 :         if (qconf.nb_atomic_order_sequences == 0)
     646                 :            :                 /* Assume PMD doesn't support reordering */
     647                 :            :                 return -ENOTSUP;
     648                 :            : 
     649                 :          1 :         qconf.schedule_type = RTE_SCHED_TYPE_ORDERED;
     650                 :            : 
     651         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     652                 :         64 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     653         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     654                 :            :         }
     655                 :            : 
     656         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     657         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
     658                 :            :                             RTE_EVENT_QUEUE_ATTR_NB_ATOMIC_ORDER_SEQUENCES,
     659                 :            :                             &nb_atomic_order_sequences),
     660                 :            :                             "Queue nb_atomic_order_sequencess get failed");
     661                 :            : 
     662         [ -  + ]:         64 :                 TEST_ASSERT_EQUAL(nb_atomic_order_sequences,
     663                 :            :                                   qconf.nb_atomic_order_sequences,
     664                 :            :                                   "Wrong atomic order sequences value for queue%d",
     665                 :            :                                   i);
     666                 :            :         }
     667                 :            : 
     668                 :            :         return TEST_SUCCESS;
     669                 :            : }
     670                 :            : 
     671                 :            : static int
     672                 :          1 : test_eventdev_queue_attr_event_queue_cfg(void)
     673                 :            : {
     674                 :            :         int i, ret;
     675                 :            :         struct rte_event_dev_info info;
     676                 :            :         struct rte_event_queue_conf qconf;
     677                 :            :         uint32_t event_queue_cfg;
     678                 :            : 
     679                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     680         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     681                 :            : 
     682                 :            :         uint32_t queue_count;
     683         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     684                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     685                 :            :                             "Queue count get failed");
     686                 :            : 
     687                 :          1 :         ret = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qconf);
     688         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 def conf");
     689                 :            : 
     690                 :          1 :         qconf.event_queue_cfg = RTE_EVENT_QUEUE_CFG_SINGLE_LINK;
     691                 :            : 
     692         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     693                 :         64 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, &qconf);
     694         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     695                 :            :         }
     696                 :            : 
     697         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     698         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(rte_event_queue_attr_get(TEST_DEV_ID, i,
     699                 :            :                                     RTE_EVENT_QUEUE_ATTR_EVENT_QUEUE_CFG,
     700                 :            :                                     &event_queue_cfg),
     701                 :            :                                     "Queue event_queue_cfg get failed");
     702                 :            : 
     703         [ -  + ]:         64 :                 TEST_ASSERT_EQUAL(event_queue_cfg, qconf.event_queue_cfg,
     704                 :            :                                   "Wrong event_queue_cfg value for queue%d",
     705                 :            :                                   i);
     706                 :            :         }
     707                 :            : 
     708                 :            :         return TEST_SUCCESS;
     709                 :            : }
     710                 :            : 
     711                 :            : static int
     712                 :          1 : test_eventdev_port_default_conf_get(void)
     713                 :            : {
     714                 :            :         int i, ret;
     715                 :            :         struct rte_event_port_conf pconf;
     716                 :            : 
     717                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, NULL);
     718         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     719                 :            : 
     720                 :            :         uint32_t port_count;
     721         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     722                 :            :                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
     723                 :            :                                 &port_count), "Port count get failed");
     724                 :            : 
     725                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID,
     726                 :          1 :                         port_count + 1, NULL);
     727         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     728                 :            : 
     729         [ +  + ]:         33 :         for (i = 0; i < (int)port_count; i++) {
     730                 :         32 :                 ret = rte_event_port_default_conf_get(TEST_DEV_ID, i,
     731                 :            :                                                         &pconf);
     732         [ -  + ]:         32 :                 TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i);
     733                 :            :         }
     734                 :            : 
     735                 :            :         return TEST_SUCCESS;
     736                 :            : }
     737                 :            : 
     738                 :            : static int
     739                 :          1 : test_eventdev_port_setup(void)
     740                 :            : {
     741                 :            :         int i, ret;
     742                 :            :         struct rte_event_dev_info info;
     743                 :            :         struct rte_event_port_conf pconf;
     744                 :            : 
     745                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     746         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     747                 :            : 
     748                 :            :         /* Negative cases */
     749                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     750         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     751                 :          1 :         pconf.new_event_threshold = info.max_num_events + 1;
     752                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     753         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     754                 :            : 
     755                 :          1 :         pconf.new_event_threshold = info.max_num_events;
     756                 :          1 :         pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1;
     757                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     758         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     759                 :            : 
     760                 :          1 :         pconf.dequeue_depth = info.max_event_port_dequeue_depth;
     761                 :          1 :         pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1;
     762                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     763         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     764                 :            : 
     765         [ +  - ]:          1 :         if (!(info.event_dev_cap &
     766                 :            :               RTE_EVENT_DEV_CAP_IMPLICIT_RELEASE_DISABLE)) {
     767                 :          1 :                 pconf.enqueue_depth = info.max_event_port_enqueue_depth;
     768                 :          1 :                 pconf.event_port_cfg = RTE_EVENT_PORT_CFG_DISABLE_IMPL_REL;
     769                 :          1 :                 ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     770         [ -  + ]:          1 :                 TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     771                 :          1 :                 pconf.event_port_cfg = 0;
     772                 :            :         }
     773                 :            : 
     774                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, info.max_event_ports,
     775                 :            :                                         &pconf);
     776         [ -  + ]:          1 :         TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     777                 :            : 
     778                 :            :         /* Positive case */
     779                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     780         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     781                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     782         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
     783                 :            : 
     784                 :            :         uint32_t port_count;
     785         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     786                 :            :                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
     787                 :            :                                 &port_count), "Port count get failed");
     788                 :            : 
     789         [ +  + ]:         32 :         for (i = 1; i < (int)port_count; i++) {
     790                 :         31 :                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
     791         [ -  + ]:         31 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
     792                 :            :         }
     793                 :            : 
     794                 :            :         return TEST_SUCCESS;
     795                 :            : }
     796                 :            : 
     797                 :            : static int
     798                 :          1 : test_eventdev_port_attr_dequeue_depth(void)
     799                 :            : {
     800                 :            :         int ret;
     801                 :            :         struct rte_event_dev_info info;
     802                 :            :         struct rte_event_port_conf pconf;
     803                 :            : 
     804                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     805         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     806                 :            : 
     807                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     808         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     809                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     810         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
     811                 :            : 
     812                 :            :         uint32_t value;
     813         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
     814                 :            :                         RTE_EVENT_PORT_ATTR_DEQ_DEPTH, &value),
     815                 :            :                         0, "Call to get port dequeue depth failed");
     816         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(value, pconf.dequeue_depth,
     817                 :            :                         "Wrong port dequeue depth");
     818                 :            : 
     819                 :            :         return TEST_SUCCESS;
     820                 :            : }
     821                 :            : 
     822                 :            : static int
     823                 :          1 : test_eventdev_port_attr_enqueue_depth(void)
     824                 :            : {
     825                 :            :         int ret;
     826                 :            :         struct rte_event_dev_info info;
     827                 :            :         struct rte_event_port_conf pconf;
     828                 :            : 
     829                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     830         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     831                 :            : 
     832                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     833         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     834                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     835         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
     836                 :            : 
     837                 :            :         uint32_t value;
     838         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
     839                 :            :                         RTE_EVENT_PORT_ATTR_ENQ_DEPTH, &value),
     840                 :            :                         0, "Call to get port enqueue depth failed");
     841         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(value, pconf.enqueue_depth,
     842                 :            :                         "Wrong port enqueue depth");
     843                 :            : 
     844                 :            :         return TEST_SUCCESS;
     845                 :            : }
     846                 :            : 
     847                 :            : static int
     848                 :          1 : test_eventdev_port_attr_new_event_threshold(void)
     849                 :            : {
     850                 :            :         int ret;
     851                 :            :         struct rte_event_dev_info info;
     852                 :            :         struct rte_event_port_conf pconf;
     853                 :            : 
     854                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     855         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     856                 :            : 
     857                 :          1 :         ret = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pconf);
     858         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info");
     859                 :          1 :         ret = rte_event_port_setup(TEST_DEV_ID, 0, &pconf);
     860         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to setup port0");
     861                 :            : 
     862                 :            :         uint32_t value;
     863         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(rte_event_port_attr_get(TEST_DEV_ID, 0,
     864                 :            :                         RTE_EVENT_PORT_ATTR_NEW_EVENT_THRESHOLD, &value),
     865                 :            :                         0, "Call to get port new event threshold failed");
     866         [ -  + ]:          1 :         TEST_ASSERT_EQUAL((int32_t) value, pconf.new_event_threshold,
     867                 :            :                         "Wrong port new event threshold");
     868                 :            : 
     869                 :            :         return TEST_SUCCESS;
     870                 :            : }
     871                 :            : 
     872                 :            : static int
     873                 :          1 : test_eventdev_port_count(void)
     874                 :            : {
     875                 :            :         int ret;
     876                 :            :         struct rte_event_dev_info info;
     877                 :            : 
     878                 :          1 :         ret = rte_event_dev_info_get(TEST_DEV_ID, &info);
     879         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info");
     880                 :            : 
     881                 :            :         uint32_t port_count;
     882         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     883                 :            :                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
     884                 :            :                                 &port_count), "Port count get failed");
     885         [ -  + ]:          1 :         TEST_ASSERT_EQUAL(port_count, info.max_event_ports, "Wrong port count");
     886                 :            : 
     887                 :            :         return TEST_SUCCESS;
     888                 :            : }
     889                 :            : 
     890                 :            : static int
     891                 :          1 : test_eventdev_timeout_ticks(void)
     892                 :            : {
     893                 :            :         int ret;
     894                 :            :         uint64_t timeout_ticks;
     895                 :            : 
     896                 :          1 :         ret = rte_event_dequeue_timeout_ticks(TEST_DEV_ID, 100, &timeout_ticks);
     897         [ +  - ]:          1 :         if (ret != -ENOTSUP)
     898         [ -  + ]:          1 :                 TEST_ASSERT_SUCCESS(ret, "Fail to get timeout_ticks");
     899                 :            : 
     900                 :            :         return ret;
     901                 :            : }
     902                 :            : 
     903                 :            : 
     904                 :            : static int
     905                 :          1 : test_eventdev_start_stop(void)
     906                 :            : {
     907                 :            :         int i, ret;
     908                 :            : 
     909                 :          1 :         ret = eventdev_configure_setup();
     910         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
     911                 :            : 
     912                 :            :         uint32_t queue_count;
     913         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     914                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     915                 :            :                             "Queue count get failed");
     916         [ +  + ]:         65 :         for (i = 0; i < (int)queue_count; i++) {
     917                 :         64 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
     918         [ -  + ]:         64 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     919                 :            :         }
     920                 :            : 
     921                 :            :         uint32_t port_count;
     922         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     923                 :            :                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
     924                 :            :                                 &port_count), "Port count get failed");
     925                 :            : 
     926         [ +  + ]:         33 :         for (i = 0; i < (int)port_count; i++) {
     927                 :         32 :                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
     928         [ -  + ]:         32 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
     929                 :            :         }
     930                 :            : 
     931                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
     932         [ -  + ]:          1 :         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
     933                 :            :                     TEST_DEV_ID);
     934                 :            : 
     935                 :          1 :         ret = rte_event_dev_start(TEST_DEV_ID);
     936         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
     937                 :            : 
     938                 :          1 :         rte_event_dev_stop(TEST_DEV_ID);
     939                 :          1 :         return TEST_SUCCESS;
     940                 :            : }
     941                 :            : 
     942                 :            : 
     943                 :            : static int
     944                 :          4 : eventdev_setup_device(void)
     945                 :            : {
     946                 :            :         int i, ret;
     947                 :            : 
     948                 :          4 :         ret = eventdev_configure_setup();
     949         [ -  + ]:          4 :         TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev");
     950                 :            : 
     951                 :            :         uint32_t queue_count;
     952         [ -  + ]:          4 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     953                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
     954                 :            :                             "Queue count get failed");
     955         [ +  + ]:        260 :         for (i = 0; i < (int)queue_count; i++) {
     956                 :        256 :                 ret = rte_event_queue_setup(TEST_DEV_ID, i, NULL);
     957         [ -  + ]:        256 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i);
     958                 :            :         }
     959                 :            : 
     960                 :            :         uint32_t port_count;
     961         [ -  + ]:          4 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     962                 :            :                                 RTE_EVENT_DEV_ATTR_PORT_COUNT,
     963                 :            :                                 &port_count), "Port count get failed");
     964                 :            : 
     965         [ +  + ]:        132 :         for (i = 0; i < (int)port_count; i++) {
     966                 :        128 :                 ret = rte_event_port_setup(TEST_DEV_ID, i, NULL);
     967         [ -  + ]:        128 :                 TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i);
     968                 :            :         }
     969                 :            : 
     970                 :          4 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
     971         [ -  + ]:          4 :         TEST_ASSERT(ret == (int)queue_count, "Failed to link port, device %d",
     972                 :            :                     TEST_DEV_ID);
     973                 :            : 
     974                 :          4 :         ret = rte_event_dev_start(TEST_DEV_ID);
     975         [ -  + ]:          4 :         TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", TEST_DEV_ID);
     976                 :            : 
     977                 :            :         return TEST_SUCCESS;
     978                 :            : }
     979                 :            : 
     980                 :            : static void
     981                 :          5 : eventdev_stop_device(void)
     982                 :            : {
     983                 :          5 :         rte_event_dev_stop(TEST_DEV_ID);
     984                 :          5 : }
     985                 :            : 
     986                 :            : static int
     987                 :          1 : test_eventdev_link(void)
     988                 :            : {
     989                 :            :         int ret, nb_queues, i;
     990                 :            :         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
     991                 :            :         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
     992                 :            : 
     993                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
     994         [ -  + ]:          1 :         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
     995                 :            :                                  TEST_DEV_ID);
     996                 :            : 
     997                 :            :         uint32_t queue_count;
     998         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
     999                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
    1000                 :            :                             "Queue count get failed");
    1001                 :          1 :         nb_queues = queue_count;
    1002         [ +  + ]:         65 :         for (i = 0; i < nb_queues; i++) {
    1003                 :         64 :                 queues[i] = i;
    1004                 :         64 :                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
    1005                 :            :         }
    1006                 :            : 
    1007                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, queues,
    1008                 :            :                                         priorities, nb_queues);
    1009         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
    1010                 :            :                                  TEST_DEV_ID, ret);
    1011                 :            :         return TEST_SUCCESS;
    1012                 :            : }
    1013                 :            : 
    1014                 :            : static int
    1015                 :          1 : test_eventdev_unlink(void)
    1016                 :            : {
    1017                 :            :         int ret, nb_queues, i;
    1018                 :            :         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
    1019                 :            : 
    1020                 :          1 :         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
    1021         [ -  + ]:          1 :         TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d",
    1022                 :            :                                  TEST_DEV_ID);
    1023                 :            : 
    1024                 :            :         uint32_t queue_count;
    1025         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
    1026                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
    1027                 :            :                             "Queue count get failed");
    1028                 :          1 :         nb_queues = queue_count;
    1029         [ +  + ]:         65 :         for (i = 0; i < nb_queues; i++)
    1030                 :         64 :                 queues[i] = i;
    1031                 :            : 
    1032                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
    1033         [ -  + ]:          1 :         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
    1034                 :            :                                  TEST_DEV_ID);
    1035                 :            : 
    1036                 :          1 :         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
    1037         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
    1038                 :            :                                  TEST_DEV_ID, ret);
    1039                 :            :         return TEST_SUCCESS;
    1040                 :            : }
    1041                 :            : 
    1042                 :            : static int
    1043                 :          1 : test_eventdev_link_get(void)
    1044                 :            : {
    1045                 :            :         int ret, i;
    1046                 :            :         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
    1047                 :            :         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
    1048                 :            : 
    1049                 :            :         /* link all queues */
    1050                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, NULL, NULL, 0);
    1051         [ -  + ]:          1 :         TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d",
    1052                 :            :                                  TEST_DEV_ID);
    1053                 :            : 
    1054                 :            :         uint32_t queue_count;
    1055         [ -  + ]:          1 :         TEST_ASSERT_SUCCESS(rte_event_dev_attr_get(TEST_DEV_ID,
    1056                 :            :                             RTE_EVENT_DEV_ATTR_QUEUE_COUNT, &queue_count),
    1057                 :            :                             "Queue count get failed");
    1058                 :          1 :         const int nb_queues = queue_count;
    1059         [ +  + ]:         65 :         for (i = 0; i < nb_queues; i++)
    1060                 :         64 :                 queues[i] = i;
    1061                 :            : 
    1062                 :          1 :         ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, nb_queues);
    1063         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
    1064                 :            :                                  TEST_DEV_ID, ret);
    1065                 :            : 
    1066                 :          1 :         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
    1067         [ -  + ]:          1 :         TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", TEST_DEV_ID, ret);
    1068                 :            : 
    1069                 :            :         /* link all queues and get the links */
    1070         [ +  + ]:         65 :         for (i = 0; i < nb_queues; i++) {
    1071                 :         64 :                 queues[i] = i;
    1072                 :         64 :                 priorities[i] = RTE_EVENT_DEV_PRIORITY_NORMAL;
    1073                 :            :         }
    1074                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
    1075                 :            :                                          nb_queues);
    1076         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d",
    1077                 :            :                                  TEST_DEV_ID, ret);
    1078                 :          1 :         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
    1079         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d",
    1080                 :            :                                  TEST_DEV_ID, ret, nb_queues);
    1081                 :            :         /* unlink all*/
    1082                 :          1 :         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
    1083         [ -  + ]:          1 :         TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d",
    1084                 :            :                                  TEST_DEV_ID, ret);
    1085                 :            :         /* link just one queue */
    1086                 :          1 :         queues[0] = 0;
    1087                 :          1 :         priorities[0] = RTE_EVENT_DEV_PRIORITY_NORMAL;
    1088                 :            : 
    1089                 :          1 :         ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities, 1);
    1090         [ -  + ]:          1 :         TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d",
    1091                 :            :                                  TEST_DEV_ID, ret);
    1092                 :          1 :         ret = rte_event_port_links_get(TEST_DEV_ID, 0, queues, priorities);
    1093         [ -  + ]:          1 :         TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d",
    1094                 :            :                                         TEST_DEV_ID, ret, 1);
    1095                 :            :         /* unlink the queue */
    1096                 :          1 :         ret = rte_event_port_unlink(TEST_DEV_ID, 0, NULL, 0);
    1097         [ -  + ]:          1 :         TEST_ASSERT(ret == 1, "Failed to unlink(device%d) ret=%d",
    1098                 :            :                                  TEST_DEV_ID, ret);
    1099                 :            : 
    1100                 :            :         /* 4links and 2 unlinks */
    1101         [ +  - ]:          1 :         if (nb_queues >= 4) {
    1102         [ +  + ]:          5 :                 for (i = 0; i < 4; i++) {
    1103                 :          4 :                         queues[i] = i;
    1104                 :          4 :                         priorities[i] = 0x40;
    1105                 :            :                 }
    1106                 :          1 :                 ret = rte_event_port_link(TEST_DEV_ID, 0, queues, priorities,
    1107                 :            :                                                 4);
    1108         [ -  + ]:          1 :                 TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d",
    1109                 :            :                                          TEST_DEV_ID, ret);
    1110                 :            : 
    1111         [ +  + ]:          3 :                 for (i = 0; i < 2; i++)
    1112                 :          2 :                         queues[i] = i;
    1113                 :            : 
    1114                 :          1 :                 ret = rte_event_port_unlink(TEST_DEV_ID, 0, queues, 2);
    1115         [ -  + ]:          1 :                 TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d",
    1116                 :            :                                          TEST_DEV_ID, ret);
    1117                 :          1 :                 ret = rte_event_port_links_get(TEST_DEV_ID, 0,
    1118                 :            :                                                 queues, priorities);
    1119         [ -  + ]:          1 :                 TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d",
    1120                 :            :                                                 TEST_DEV_ID, ret, 2);
    1121         [ -  + ]:          1 :                 TEST_ASSERT(queues[0] == 2, "ret=%d expected=%d", ret, 2);
    1122         [ -  + ]:          1 :                 TEST_ASSERT(priorities[0] == 0x40, "ret=%d expected=%d",
    1123                 :            :                                                         ret, 0x40);
    1124         [ -  + ]:          1 :                 TEST_ASSERT(queues[1] == 3, "ret=%d expected=%d", ret, 3);
    1125         [ -  + ]:          1 :                 TEST_ASSERT(priorities[1] == 0x40, "ret=%d expected=%d",
    1126                 :            :                                         ret, 0x40);
    1127                 :            :         }
    1128                 :            : 
    1129                 :            :         return TEST_SUCCESS;
    1130                 :            : }
    1131                 :            : 
    1132                 :            : static int
    1133                 :          1 : test_eventdev_profile_switch(void)
    1134                 :            : {
    1135                 :            : #define MAX_RETRIES   4
    1136                 :            :         uint8_t priorities[RTE_EVENT_MAX_QUEUES_PER_DEV];
    1137                 :            :         uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV];
    1138                 :            :         struct rte_event_queue_conf qcfg;
    1139                 :            :         struct rte_event_port_conf pcfg;
    1140                 :            :         struct rte_event_dev_info info;
    1141                 :            :         struct rte_event ev;
    1142                 :            :         uint8_t q, re;
    1143                 :            :         int rc;
    1144                 :            : 
    1145                 :          1 :         rte_event_dev_info_get(TEST_DEV_ID, &info);
    1146                 :            : 
    1147         [ -  + ]:          1 :         if (info.max_profiles_per_port <= 1)
    1148                 :            :                 return TEST_SKIPPED;
    1149                 :            : 
    1150         [ #  # ]:          0 :         if (info.max_event_queues <= 1)
    1151                 :            :                 return TEST_SKIPPED;
    1152                 :            : 
    1153                 :          0 :         rc = rte_event_port_default_conf_get(TEST_DEV_ID, 0, &pcfg);
    1154         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to get port0 default config");
    1155                 :          0 :         rc = rte_event_port_setup(TEST_DEV_ID, 0, &pcfg);
    1156         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to setup port0");
    1157                 :            : 
    1158                 :          0 :         rc = rte_event_queue_default_conf_get(TEST_DEV_ID, 0, &qcfg);
    1159         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to get queue0 default config");
    1160                 :          0 :         rc = rte_event_queue_setup(TEST_DEV_ID, 0, &qcfg);
    1161         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to setup queue0");
    1162                 :            : 
    1163                 :          0 :         q = 0;
    1164                 :          0 :         rc = rte_event_port_profile_links_set(TEST_DEV_ID, 0, &q, NULL, 1, 0);
    1165         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to link queue 0 to port 0 with profile 0");
    1166                 :          0 :         q = 1;
    1167                 :          0 :         rc = rte_event_port_profile_links_set(TEST_DEV_ID, 0, &q, NULL, 1, 1);
    1168         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to link queue 1 to port 0 with profile 1");
    1169                 :            : 
    1170                 :          0 :         rc = rte_event_port_profile_links_get(TEST_DEV_ID, 0, queues, priorities, 0);
    1171         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to links");
    1172         [ #  # ]:          0 :         TEST_ASSERT(queues[0] == 0, "Invalid queue found in link");
    1173                 :            : 
    1174                 :          0 :         rc = rte_event_port_profile_links_get(TEST_DEV_ID, 0, queues, priorities, 1);
    1175         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to links");
    1176         [ #  # ]:          0 :         TEST_ASSERT(queues[0] == 1, "Invalid queue found in link");
    1177                 :            : 
    1178                 :          0 :         rc = rte_event_dev_start(TEST_DEV_ID);
    1179         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to start event device");
    1180                 :            : 
    1181                 :          0 :         ev.event_type = RTE_EVENT_TYPE_CPU;
    1182                 :          0 :         ev.queue_id = 0;
    1183                 :          0 :         ev.op = RTE_EVENT_OP_NEW;
    1184                 :          0 :         ev.flow_id = 0;
    1185                 :          0 :         ev.u64 = 0xBADF00D0;
    1186                 :            :         rc = rte_event_enqueue_burst(TEST_DEV_ID, 0, &ev, 1);
    1187         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to enqueue event");
    1188                 :          0 :         ev.queue_id = 1;
    1189                 :          0 :         ev.flow_id = 1;
    1190                 :            :         rc = rte_event_enqueue_burst(TEST_DEV_ID, 0, &ev, 1);
    1191         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to enqueue event");
    1192                 :            : 
    1193                 :          0 :         ev.event = 0;
    1194                 :          0 :         ev.u64 = 0;
    1195                 :            : 
    1196                 :            :         rc = rte_event_port_profile_switch(TEST_DEV_ID, 0, 1);
    1197         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to change profile");
    1198                 :            : 
    1199                 :            :         re = MAX_RETRIES;
    1200         [ #  # ]:          0 :         while (re--) {
    1201                 :          0 :                 rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
    1202                 :            :                 printf("rc %d\n", rc);
    1203         [ #  # ]:          0 :                 if (rc)
    1204                 :            :                         break;
    1205                 :            :         }
    1206                 :            : 
    1207         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to dequeue event from profile 1");
    1208         [ #  # ]:          0 :         TEST_ASSERT(ev.flow_id == 1, "Incorrect flow identifier from profile 1");
    1209         [ #  # ]:          0 :         TEST_ASSERT(ev.queue_id == 1, "Incorrect queue identifier from profile 1");
    1210                 :            : 
    1211                 :            :         re = MAX_RETRIES;
    1212         [ #  # ]:          0 :         while (re--) {
    1213                 :            :                 rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
    1214         [ #  # ]:          0 :                 TEST_ASSERT(rc == 0, "Unexpected event dequeued from active profile");
    1215                 :            :         }
    1216                 :            : 
    1217                 :            :         rc = rte_event_port_profile_switch(TEST_DEV_ID, 0, 0);
    1218         [ #  # ]:          0 :         TEST_ASSERT_SUCCESS(rc, "Failed to change profile");
    1219                 :            : 
    1220                 :            :         re = MAX_RETRIES;
    1221         [ #  # ]:          0 :         while (re--) {
    1222                 :          0 :                 rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
    1223         [ #  # ]:          0 :                 if (rc)
    1224                 :            :                         break;
    1225                 :            :         }
    1226                 :            : 
    1227         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to dequeue event from profile 1");
    1228         [ #  # ]:          0 :         TEST_ASSERT(ev.flow_id == 0, "Incorrect flow identifier from profile 0");
    1229         [ #  # ]:          0 :         TEST_ASSERT(ev.queue_id == 0, "Incorrect queue identifier from profile 0");
    1230                 :            : 
    1231                 :            :         re = MAX_RETRIES;
    1232         [ #  # ]:          0 :         while (re--) {
    1233                 :            :                 rc = rte_event_dequeue_burst(TEST_DEV_ID, 0, &ev, 1, 0);
    1234         [ #  # ]:          0 :                 TEST_ASSERT(rc == 0, "Unexpected event dequeued from active profile");
    1235                 :            :         }
    1236                 :            : 
    1237                 :          0 :         q = 0;
    1238                 :          0 :         rc = rte_event_port_profile_unlink(TEST_DEV_ID, 0, &q, 1, 0);
    1239         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to unlink queue 0 to port 0 with profile 0");
    1240                 :          0 :         q = 1;
    1241                 :          0 :         rc = rte_event_port_profile_unlink(TEST_DEV_ID, 0, &q, 1, 1);
    1242         [ #  # ]:          0 :         TEST_ASSERT(rc == 1, "Failed to unlink queue 1 to port 0 with profile 1");
    1243                 :            : 
    1244                 :            :         return TEST_SUCCESS;
    1245                 :            : }
    1246                 :            : 
    1247                 :            : static int
    1248                 :          1 : test_eventdev_close(void)
    1249                 :            : {
    1250                 :          1 :         rte_event_dev_stop(TEST_DEV_ID);
    1251                 :          1 :         return rte_event_dev_close(TEST_DEV_ID);
    1252                 :            : }
    1253                 :            : 
    1254                 :            : static struct unit_test_suite eventdev_common_testsuite  = {
    1255                 :            :         .suite_name = "eventdev common code unit test suite",
    1256                 :            :         .setup = testsuite_setup,
    1257                 :            :         .teardown = testsuite_teardown,
    1258                 :            :         .unit_test_cases = {
    1259                 :            :                 TEST_CASE_ST(NULL, NULL,
    1260                 :            :                         test_eventdev_count),
    1261                 :            :                 TEST_CASE_ST(NULL, NULL,
    1262                 :            :                         test_eventdev_get_dev_id),
    1263                 :            :                 TEST_CASE_ST(NULL, NULL,
    1264                 :            :                         test_eventdev_socket_id),
    1265                 :            :                 TEST_CASE_ST(NULL, NULL,
    1266                 :            :                         test_eventdev_info_get),
    1267                 :            :                 TEST_CASE_ST(NULL, NULL,
    1268                 :            :                         test_eventdev_configure),
    1269                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1270                 :            :                         test_eventdev_queue_default_conf_get),
    1271                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1272                 :            :                         test_eventdev_queue_setup),
    1273                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1274                 :            :                         test_eventdev_queue_count),
    1275                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1276                 :            :                         test_eventdev_queue_attr_priority),
    1277                 :            :                 TEST_CASE_ST(eventdev_configure_setup, eventdev_stop_device,
    1278                 :            :                         test_eventdev_queue_attr_priority_runtime),
    1279                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1280                 :            :                         test_eventdev_queue_attr_weight_runtime),
    1281                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1282                 :            :                         test_eventdev_queue_attr_affinity_runtime),
    1283                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1284                 :            :                         test_eventdev_queue_attr_nb_atomic_flows),
    1285                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1286                 :            :                         test_eventdev_queue_attr_nb_atomic_order_sequences),
    1287                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1288                 :            :                         test_eventdev_queue_attr_event_queue_cfg),
    1289                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1290                 :            :                         test_eventdev_port_default_conf_get),
    1291                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1292                 :            :                         test_eventdev_port_setup),
    1293                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1294                 :            :                         test_eventdev_port_attr_dequeue_depth),
    1295                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1296                 :            :                         test_eventdev_port_attr_enqueue_depth),
    1297                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1298                 :            :                         test_eventdev_port_attr_new_event_threshold),
    1299                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1300                 :            :                         test_eventdev_port_count),
    1301                 :            :                 TEST_CASE_ST(eventdev_configure_setup, NULL,
    1302                 :            :                         test_eventdev_timeout_ticks),
    1303                 :            :                 TEST_CASE_ST(NULL, NULL,
    1304                 :            :                         test_eventdev_start_stop),
    1305                 :            :                 TEST_CASE_ST(eventdev_configure_setup, eventdev_stop_device,
    1306                 :            :                         test_eventdev_profile_switch),
    1307                 :            :                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
    1308                 :            :                         test_eventdev_link),
    1309                 :            :                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
    1310                 :            :                         test_eventdev_unlink),
    1311                 :            :                 TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device,
    1312                 :            :                         test_eventdev_link_get),
    1313                 :            :                 TEST_CASE_ST(eventdev_setup_device, NULL,
    1314                 :            :                         test_eventdev_close),
    1315                 :            :                 TEST_CASES_END() /**< NULL terminate unit test array */
    1316                 :            :         }
    1317                 :            : };
    1318                 :            : 
    1319                 :            : static int
    1320                 :          1 : test_eventdev_common(void)
    1321                 :            : {
    1322                 :          1 :         return unit_test_suite_runner(&eventdev_common_testsuite);
    1323                 :            : }
    1324                 :            : 
    1325                 :            : static int
    1326                 :          1 : test_eventdev_selftest_impl(const char *pmd, const char *opts)
    1327                 :            : {
    1328                 :            :         int ret = 0;
    1329                 :            : 
    1330         [ +  - ]:          1 :         if (rte_event_dev_get_dev_id(pmd) == -ENODEV)
    1331                 :          1 :                 ret = rte_vdev_init(pmd, opts);
    1332         [ +  - ]:          1 :         if (ret)
    1333                 :            :                 return TEST_SKIPPED;
    1334                 :            : 
    1335                 :          1 :         return rte_event_dev_selftest(rte_event_dev_get_dev_id(pmd));
    1336                 :            : }
    1337                 :            : 
    1338                 :            : static int
    1339                 :          1 : test_eventdev_selftest_sw(void)
    1340                 :            : {
    1341                 :          1 :         return test_eventdev_selftest_impl("event_sw", "");
    1342                 :            : }
    1343                 :            : 
    1344                 :            : static int
    1345                 :          0 : test_eventdev_selftest_octeontx(void)
    1346                 :            : {
    1347                 :          0 :         return test_eventdev_selftest_impl("event_octeontx", "");
    1348                 :            : }
    1349                 :            : 
    1350                 :            : static int
    1351                 :          0 : test_eventdev_selftest_dpaa2(void)
    1352                 :            : {
    1353                 :          0 :         return test_eventdev_selftest_impl("event_dpaa2", "");
    1354                 :            : }
    1355                 :            : 
    1356                 :            : static int
    1357                 :          0 : test_eventdev_selftest_dlb2(void)
    1358                 :            : {
    1359                 :          0 :         return test_eventdev_selftest_impl("dlb2_event", "");
    1360                 :            : }
    1361                 :            : 
    1362                 :            : static int
    1363                 :          0 : test_eventdev_selftest_cn9k(void)
    1364                 :            : {
    1365                 :          0 :         return test_eventdev_selftest_impl("event_cn9k", "");
    1366                 :            : }
    1367                 :            : 
    1368                 :            : static int
    1369                 :          0 : test_eventdev_selftest_cn10k(void)
    1370                 :            : {
    1371                 :          0 :         return test_eventdev_selftest_impl("event_cn10k", "");
    1372                 :            : }
    1373                 :            : 
    1374                 :            : #endif /* !RTE_EXEC_ENV_WINDOWS */
    1375                 :            : 
    1376                 :        235 : REGISTER_FAST_TEST(eventdev_common_autotest, true, true, test_eventdev_common);
    1377                 :            : 
    1378                 :            : #ifndef RTE_EXEC_ENV_WINDOWS
    1379                 :        235 : REGISTER_FAST_TEST(eventdev_selftest_sw, true, true, test_eventdev_selftest_sw);
    1380                 :        235 : REGISTER_DRIVER_TEST(eventdev_selftest_octeontx, test_eventdev_selftest_octeontx);
    1381                 :        235 : REGISTER_DRIVER_TEST(eventdev_selftest_dpaa2, test_eventdev_selftest_dpaa2);
    1382                 :        235 : REGISTER_DRIVER_TEST(eventdev_selftest_dlb2, test_eventdev_selftest_dlb2);
    1383                 :        235 : REGISTER_DRIVER_TEST(eventdev_selftest_cn9k, test_eventdev_selftest_cn9k);
    1384                 :        235 : REGISTER_DRIVER_TEST(eventdev_selftest_cn10k, test_eventdev_selftest_cn10k);
    1385                 :            : 
    1386                 :            : #endif /* !RTE_EXEC_ENV_WINDOWS */

Generated by: LCOV version 1.14