app/test/test_event_ring.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2017 Intel Corporation
   3  */
   4
   5 #include "test.h"
   6
   7 #include <string.h>
   8
   9 #ifdef RTE_EXEC_ENV_WINDOWS
  10 static int
  11 test_event_ring(void)
  12 {
  13         printf("event_ring not supported on Windows, skipping test\n");
  14         return TEST_SKIPPED;
  15 }
  16
  17 #else
  18
  19 #include <rte_event_ring.h>
  20
  21 /*
  22  * Event Ring
  23  * ===========
  24  *
  25  * Test some basic ops for the event rings.
  26  * Does not fully test everything, since most code is reused from rte_ring
  27  * library and tested as part of the normal ring autotests.
  28  */
  29
  30 #define RING_SIZE 4096
  31 #define MAX_BULK 32
  32
  33 static struct rte_event_ring *r;
  34
  35 /*
  36  * ensure failure to create ring with a bad ring size
  37  */
  38 static int
  39 test_event_ring_creation_with_wrong_size(void)
  40 {
  41         struct rte_event_ring *rp = NULL;
  42
  43         /* Test if ring size is not power of 2 */
  44         rp = rte_event_ring_create("test_bad_ring_size", RING_SIZE + 1,
  45                         SOCKET_ID_ANY, 0);
  46         if (rp != NULL)
  47                 return -1;
  48
  49         /* Test if ring size is exceeding the limit */
  50         rp = rte_event_ring_create("test_bad_ring_size", (RTE_RING_SZ_MASK + 1),
  51                         SOCKET_ID_ANY, 0);
  52         if (rp != NULL)
  53                 return -1;
  54         return 0;
  55 }
  56
  57 /*
  58  * Test to check if a non-power-of-2 count causes the create
  59  * function to fail correctly
  60  */
  61 static int
  62 test_create_count_odd(void)
  63 {
  64         struct rte_event_ring *r = rte_event_ring_create("test_event_ring_count",
  65                         4097, SOCKET_ID_ANY, 0);
  66         if (r != NULL)
  67                 return -1;
  68         return 0;
  69 }
  70
  71 static int
  72 test_lookup_null(void)
  73 {
  74         struct rte_event_ring *rlp = rte_event_ring_lookup("ring_not_found");
  75         if (rlp == NULL && rte_errno != ENOENT) {
  76                 printf("test failed to return error on null pointer\n");
  77                 return -1;
  78         }
  79         return 0;
  80 }
  81
  82 static int
  83 test_basic_event_enqueue_dequeue(void)
  84 {
  85         struct rte_event_ring *sr = NULL;
  86         struct rte_event evs[16];
  87         uint16_t ret, free_count, used_count;
  88
  89         memset(evs, 0, sizeof(evs));
  90         sr = rte_event_ring_create("spsc_ring", 32, rte_socket_id(),
  91                         RING_F_SP_ENQ | RING_F_SC_DEQ);
  92         if (sr == NULL) {
  93                 printf("Failed to create sp/sc ring\n");
  94                 return -1;
  95         }
  96         if (rte_event_ring_get_capacity(sr) != 31) {
  97                 printf("Error, invalid capacity\n");
  98                 goto error;
  99         }
 100
 101         /* test sp/sc ring */
 102         if (rte_event_ring_count(sr) != 0) {
 103                 printf("Error, ring not empty as expected\n");
 104                 goto error;
 105         }
 106         if (rte_event_ring_free_count(sr) != rte_event_ring_get_capacity(sr)) {
 107                 printf("Error, ring free count not as expected\n");
 108                 goto error;
 109         }
 110
 111         ret = rte_event_ring_enqueue_burst(sr, evs, RTE_DIM(evs), &free_count);
 112         if (ret != RTE_DIM(evs) ||
 113                         free_count != rte_event_ring_get_capacity(sr) - ret) {
 114                 printf("Error, status after enqueue is unexpected\n");
 115                 goto error;
 116         }
 117
 118         ret = rte_event_ring_enqueue_burst(sr, evs, RTE_DIM(evs), &free_count);
 119         if (ret != RTE_DIM(evs) - 1 ||
 120                         free_count != 0) {
 121                 printf("Error, status after enqueue is unexpected\n");
 122                 goto error;
 123         }
 124
 125         ret = rte_event_ring_dequeue_burst(sr, evs, RTE_DIM(evs), &used_count);
 126         if (ret != RTE_DIM(evs) ||
 127                         used_count != rte_event_ring_get_capacity(sr) - ret) {
 128                 printf("Error, status after enqueue is unexpected\n");
 129                 goto error;
 130         }
 131         ret = rte_event_ring_dequeue_burst(sr, evs, RTE_DIM(evs), &used_count);
 132         if (ret != RTE_DIM(evs) - 1 ||
 133                         used_count != 0) {
 134                 printf("Error, status after enqueue is unexpected\n");
 135                 goto error;
 136         }
 137
 138         rte_event_ring_free(sr);
 139         return 0;
 140 error:
 141         rte_event_ring_free(sr);
 142         return -1;
 143 }
 144
 145 static int
 146 test_event_ring_with_exact_size(void)
 147 {
 148         struct rte_event_ring *std_ring, *exact_sz_ring;
 149         struct rte_event ev = { .mbuf = NULL };
 150         struct rte_event ev_array[16];
 151         static const unsigned int ring_sz = RTE_DIM(ev_array);
 152         unsigned int i;
 153
 154         std_ring = rte_event_ring_create("std", ring_sz, rte_socket_id(),
 155                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 156         if (std_ring == NULL) {
 157                 printf("%s: error, can't create std ring\n", __func__);
 158                 return -1;
 159         }
 160         exact_sz_ring = rte_event_ring_create("exact sz",
 161                         ring_sz, rte_socket_id(),
 162                         RING_F_SP_ENQ | RING_F_SC_DEQ | RING_F_EXACT_SZ);
 163         if (exact_sz_ring == NULL) {
 164                 printf("%s: error, can't create exact size ring\n", __func__);
 165                 return -1;
 166         }
 167
 168         /*
 169          * Check that the exact size ring is bigger than the standard ring
 170          */
 171         if (rte_event_ring_get_size(std_ring) >=
 172                         rte_event_ring_get_size(exact_sz_ring)) {
 173                 printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
 174                                 __func__,
 175                                 rte_event_ring_get_size(std_ring),
 176                                 rte_event_ring_get_size(exact_sz_ring));
 177                 return -1;
 178         }
 179         /*
 180          * check that the exact_sz_ring can hold one more element than the
 181          * standard ring. (16 vs 15 elements)
 182          */
 183         for (i = 0; i < ring_sz - 1; i++) {
 184                 rte_event_ring_enqueue_burst(std_ring, &ev, 1, NULL);
 185                 rte_event_ring_enqueue_burst(exact_sz_ring, &ev, 1, NULL);
 186         }
 187         if (rte_event_ring_enqueue_burst(std_ring, &ev, 1, NULL) != 0) {
 188                 printf("%s: error, unexpected successful enqueue\n", __func__);
 189                 return -1;
 190         }
 191         if (rte_event_ring_enqueue_burst(exact_sz_ring, &ev, 1, NULL) != 1) {
 192                 printf("%s: error, enqueue failed\n", __func__);
 193                 return -1;
 194         }
 195
 196         /* check that dequeue returns the expected number of elements */
 197         if (rte_event_ring_dequeue_burst(exact_sz_ring, ev_array,
 198                         RTE_DIM(ev_array), NULL) != ring_sz) {
 199                 printf("%s: error, failed to dequeue expected nb of elements\n",
 200                                 __func__);
 201                 return -1;
 202         }
 203
 204         /* check that the capacity function returns expected value */
 205         if (rte_event_ring_get_capacity(exact_sz_ring) != ring_sz) {
 206                 printf("%s: error, incorrect ring capacity reported\n",
 207                                 __func__);
 208                 return -1;
 209         }
 210
 211         rte_event_ring_free(std_ring);
 212         rte_event_ring_free(exact_sz_ring);
 213         return 0;
 214 }
 215
 216 static int
 217 test_event_ring(void)
 218 {
 219         if (r == NULL)
 220                 r = rte_event_ring_create("ev_test", RING_SIZE,
 221                                 SOCKET_ID_ANY, 0);
 222         if (r == NULL)
 223                 return -1;
 224
 225         /* retrieve the ring from its name */
 226         if (rte_event_ring_lookup("ev_test") != r) {
 227                 printf("Cannot lookup ring from its name\n");
 228                 return -1;
 229         }
 230
 231         /* basic operations */
 232         if (test_create_count_odd() < 0) {
 233                 printf("Test failed to detect odd count\n");
 234                 return -1;
 235         }
 236         printf("Test detected odd count\n");
 237
 238         if (test_lookup_null() < 0) {
 239                 printf("Test failed to detect NULL ring lookup\n");
 240                 return -1;
 241         }
 242         printf("Test detected NULL ring lookup\n");
 243
 244         /* test of creating ring with wrong size */
 245         if (test_event_ring_creation_with_wrong_size() < 0)
 246                 return -1;
 247
 248         if (test_basic_event_enqueue_dequeue() < 0)
 249                 return -1;
 250
 251         if (test_event_ring_with_exact_size() < 0)
 252                 return -1;
 253
 254         return 0;
 255 }
 256
 257 #endif /* !RTE_EXEC_ENV_WINDOWS */
 258
 259 REGISTER_TEST_COMMAND(event_ring_autotest, test_event_ring);