app/test/test_reorder.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <unistd.h>
   7 #include <string.h>
   8
   9 #include <rte_cycles.h>
  10 #include <rte_errno.h>
  11 #include <rte_mbuf.h>
  12 #include <rte_reorder.h>
  13 #include <rte_lcore.h>
  14 #include <rte_malloc.h>
  15
  16 #include "test.h"
  17
  18 #define BURST 32
  19 #define REORDER_BUFFER_SIZE 16384
  20 #define NUM_MBUFS (2*REORDER_BUFFER_SIZE)
  21 #define REORDER_BUFFER_SIZE_INVALID 2049
  22
  23 struct reorder_unittest_params {
  24         struct rte_mempool *p;
  25         struct rte_reorder_buffer *b;
  26 };
  27
  28 static struct reorder_unittest_params default_params  = {
  29         .p = NULL,
  30         .b = NULL
  31 };
  32
  33 static struct reorder_unittest_params *test_params = &default_params;
  34
  35 static int
  36 test_reorder_create(void)
  37 {
  38         struct rte_reorder_buffer *b = NULL;
  39
  40         b = rte_reorder_create(NULL, rte_socket_id(), REORDER_BUFFER_SIZE);
  41         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  42                         "No error on create() with NULL name");
  43
  44         b = rte_reorder_create("PKT", rte_socket_id(), REORDER_BUFFER_SIZE_INVALID);
  45         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  46                         "No error on create() with invalid buffer size param.");
  47
  48         b = rte_reorder_create("PKT_RO1", rte_socket_id(), REORDER_BUFFER_SIZE);
  49         TEST_ASSERT_EQUAL(b, test_params->b,
  50                         "New reorder instance created with already existing name");
  51
  52         return 0;
  53 }
  54
  55 static int
  56 test_reorder_init(void)
  57 {
  58         struct rte_reorder_buffer *b = NULL;
  59         unsigned int size;
  60         /*
  61          * The minimum memory area size that should be passed to library is,
  62          * sizeof(struct rte_reorder_buffer) + (2 * size * sizeof(struct rte_mbuf *));
  63          * Otherwise error will be thrown
  64          */
  65
  66         size = 100;
  67         b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
  68         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  69                         "No error on init with NULL buffer.");
  70
  71         b = rte_malloc(NULL, size, 0);
  72         b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE);
  73         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  74                         "No error on init with invalid mem zone size.");
  75         rte_free(b);
  76
  77         size = 262336;
  78         b = rte_malloc(NULL, size, 0);
  79         b = rte_reorder_init(b, size, "PKT1", REORDER_BUFFER_SIZE_INVALID);
  80         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  81                         "No error on init with invalid buffer size param.");
  82
  83         b = rte_reorder_init(b, size, NULL, REORDER_BUFFER_SIZE);
  84         TEST_ASSERT((b == NULL) && (rte_errno == EINVAL),
  85                         "No error on init with invalid name.");
  86         rte_free(b);
  87
  88         return 0;
  89 }
  90
  91 static int
  92 test_reorder_find_existing(void)
  93 {
  94         struct rte_reorder_buffer *b = NULL;
  95
  96         /* Try to find existing reorder buffer instance */
  97         b = rte_reorder_find_existing("PKT_RO1");
  98         TEST_ASSERT_EQUAL(b, test_params->b,
  99                         "existing reorder buffer instance not found");
 100
 101         /* Try to find non existing reorder buffer instance */
 102         b = rte_reorder_find_existing("ro_find_non_existing");
 103         TEST_ASSERT((b == NULL) && (rte_errno == ENOENT),
 104                         "non existing reorder buffer instance found");
 105
 106         return 0;
 107 }
 108
 109 static int
 110 test_reorder_free(void)
 111 {
 112         struct rte_reorder_buffer *b1 = NULL, *b2 = NULL;
 113         const char *name = "test_free";
 114
 115         b1 = rte_reorder_create(name, rte_socket_id(), 8);
 116         TEST_ASSERT_NOT_NULL(b1, "Failed to create reorder buffer.");
 117
 118         b2 = rte_reorder_find_existing(name);
 119         TEST_ASSERT_EQUAL(b1, b2, "Failed to find existing reorder buffer");
 120
 121         rte_reorder_free(b1);
 122
 123         b2 = rte_reorder_find_existing(name);
 124         TEST_ASSERT((b2 == NULL) && (rte_errno == ENOENT),
 125                         "Found previously freed reorder buffer");
 126
 127         return 0;
 128 }
 129
 130 static int
 131 test_reorder_insert(void)
 132 {
 133         struct rte_reorder_buffer *b = NULL;
 134         struct rte_mempool *p = test_params->p;
 135         const unsigned int size = 4;
 136         const unsigned int num_bufs = 7;
 137         struct rte_mbuf *bufs[num_bufs];
 138         int ret = 0;
 139         unsigned i;
 140
 141         /* This would create a reorder buffer instance consisting of:
 142          * reorder_seq = 0
 143          * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
 144          * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
 145          */
 146         b = rte_reorder_create("test_insert", rte_socket_id(), size);
 147         TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
 148
 149         for (i = 0; i < num_bufs; i++) {
 150                 bufs[i] = rte_pktmbuf_alloc(p);
 151                 TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
 152                 bufs[i]->seqn = i;
 153         }
 154
 155         /* This should fill up order buffer:
 156          * reorder_seq = 0
 157          * RB[] = {NULL, NULL, NULL, NULL}
 158          * OB[] = {0, 1, 2, 3}
 159          */
 160         for (i = 0; i < size; i++) {
 161                 ret = rte_reorder_insert(b, bufs[i]);
 162                 if (ret != 0) {
 163                         printf("%s:%d: Error inserting packet with seqn less than size\n",
 164                                         __func__, __LINE__);
 165                         ret = -1;
 166                         goto exit;
 167                 }
 168                 bufs[i] = NULL;
 169         }
 170
 171         /* early packet - should move mbufs to ready buf and move sequence window
 172          * reorder_seq = 4
 173          * RB[] = {0, 1, 2, 3}
 174          * OB[] = {4, NULL, NULL, NULL}
 175          */
 176         ret = rte_reorder_insert(b, bufs[4]);
 177         if (ret != 0) {
 178                 printf("%s:%d: Error inserting early packet with seqn: size\n",
 179                                 __func__, __LINE__);
 180                 ret = -1;
 181                 goto exit;
 182         }
 183         bufs[4] = NULL;
 184
 185         /* early packet from current sequence window - full ready buffer */
 186         bufs[5]->seqn = 2 * size;
 187         ret = rte_reorder_insert(b, bufs[5]);
 188         if (!((ret == -1) && (rte_errno == ENOSPC))) {
 189                 printf("%s:%d: No error inserting early packet with full ready buffer\n",
 190                                 __func__, __LINE__);
 191                 ret = -1;
 192                 goto exit;
 193         }
 194         bufs[5] = NULL;
 195
 196         /* late packet */
 197         bufs[6]->seqn = 3 * size;
 198         ret = rte_reorder_insert(b, bufs[6]);
 199         if (!((ret == -1) && (rte_errno == ERANGE))) {
 200                 printf("%s:%d: No error inserting late packet with seqn:"
 201                                 " 3 * size\n", __func__, __LINE__);
 202                 ret = -1;
 203                 goto exit;
 204         }
 205         bufs[6] = NULL;
 206
 207         ret = 0;
 208 exit:
 209         rte_reorder_free(b);
 210         for (i = 0; i < num_bufs; i++) {
 211                 if (bufs[i] != NULL)
 212                         rte_pktmbuf_free(bufs[i]);
 213         }
 214         return ret;
 215 }
 216
 217 static int
 218 test_reorder_drain(void)
 219 {
 220         struct rte_reorder_buffer *b = NULL;
 221         struct rte_mempool *p = test_params->p;
 222         const unsigned int size = 4;
 223         const unsigned int num_bufs = 8;
 224         struct rte_mbuf *bufs[num_bufs];
 225         struct rte_mbuf *robufs[num_bufs];
 226         int ret = 0;
 227         unsigned i, cnt;
 228
 229         /* initialize all robufs to NULL */
 230         for (i = 0; i < num_bufs; i++)
 231                 robufs[i] = NULL;
 232
 233         /* This would create a reorder buffer instance consisting of:
 234          * reorder_seq = 0
 235          * ready_buf: RB[size] = {NULL, NULL, NULL, NULL}
 236          * order_buf: OB[size] = {NULL, NULL, NULL, NULL}
 237          */
 238         b = rte_reorder_create("test_drain", rte_socket_id(), size);
 239         TEST_ASSERT_NOT_NULL(b, "Failed to create reorder buffer");
 240
 241         /* Check no drained packets if reorder is empty */
 242         cnt = rte_reorder_drain(b, robufs, 1);
 243         if (cnt != 0) {
 244                 printf("%s:%d: drained packets from empty reorder buffer\n",
 245                                 __func__, __LINE__);
 246                 ret = -1;
 247                 goto exit;
 248         }
 249
 250         for (i = 0; i < num_bufs; i++) {
 251                 bufs[i] = rte_pktmbuf_alloc(p);
 252                 TEST_ASSERT_NOT_NULL(bufs[i], "Packet allocation failed\n");
 253                 bufs[i]->seqn = i;
 254         }
 255
 256         /* Insert packet with seqn 1:
 257          * reorder_seq = 0
 258          * RB[] = {NULL, NULL, NULL, NULL}
 259          * OB[] = {1, NULL, NULL, NULL}
 260          */
 261         rte_reorder_insert(b, bufs[1]);
 262         bufs[1] = NULL;
 263
 264         cnt = rte_reorder_drain(b, robufs, 1);
 265         if (cnt != 1) {
 266                 printf("%s:%d:%d: number of expected packets not drained\n",
 267                                 __func__, __LINE__, cnt);
 268                 ret = -1;
 269                 goto exit;
 270         }
 271         if (robufs[0] != NULL)
 272                 rte_pktmbuf_free(robufs[0]);
 273
 274         /* Insert more packets
 275          * RB[] = {NULL, NULL, NULL, NULL}
 276          * OB[] = {NULL, 2, 3, NULL}
 277          */
 278         rte_reorder_insert(b, bufs[2]);
 279         rte_reorder_insert(b, bufs[3]);
 280         bufs[2] = NULL;
 281         bufs[3] = NULL;
 282
 283         /* Insert more packets
 284          * RB[] = {NULL, NULL, NULL, NULL}
 285          * OB[] = {NULL, 2, 3, 4}
 286          */
 287         rte_reorder_insert(b, bufs[4]);
 288         bufs[4] = NULL;
 289
 290         /* Insert more packets
 291          * RB[] = {2, 3, 4, NULL}
 292          * OB[] = {NULL, NULL, 7, NULL}
 293          */
 294         rte_reorder_insert(b, bufs[7]);
 295         bufs[7] = NULL;
 296
 297         /* drained expected packets */
 298         cnt = rte_reorder_drain(b, robufs, 4);
 299         if (cnt != 3) {
 300                 printf("%s:%d:%d: number of expected packets not drained\n",
 301                                 __func__, __LINE__, cnt);
 302                 ret = -1;
 303                 goto exit;
 304         }
 305         for (i = 0; i < 3; i++) {
 306                 if (robufs[i] != NULL)
 307                         rte_pktmbuf_free(robufs[i]);
 308         }
 309
 310         /*
 311          * RB[] = {NULL, NULL, NULL, NULL}
 312          * OB[] = {NULL, NULL, 7, NULL}
 313          */
 314         cnt = rte_reorder_drain(b, robufs, 1);
 315         if (cnt != 0) {
 316                 printf("%s:%d:%d: number of expected packets not drained\n",
 317                                 __func__, __LINE__, cnt);
 318                 ret = -1;
 319                 goto exit;
 320         }
 321         ret = 0;
 322 exit:
 323         rte_reorder_free(b);
 324         for (i = 0; i < num_bufs; i++) {
 325                 if (bufs[i] != NULL)
 326                         rte_pktmbuf_free(bufs[i]);
 327                 if (robufs[i] != NULL)
 328                         rte_pktmbuf_free(robufs[i]);
 329         }
 330         return ret;
 331 }
 332
 333 static int
 334 test_setup(void)
 335 {
 336         /* reorder buffer instance creation */
 337         if (test_params->b == NULL) {
 338                 test_params->b = rte_reorder_create("PKT_RO1", rte_socket_id(),
 339                                                         REORDER_BUFFER_SIZE);
 340                 if (test_params->b == NULL) {
 341                         printf("%s: Error creating reorder buffer instance b\n",
 342                                         __func__);
 343                         return -1;
 344                 }
 345         } else
 346                 rte_reorder_reset(test_params->b);
 347
 348         /* mempool creation */
 349         if (test_params->p == NULL) {
 350                 test_params->p = rte_pktmbuf_pool_create("RO_MBUF_POOL",
 351                         NUM_MBUFS, BURST, 0, RTE_MBUF_DEFAULT_BUF_SIZE,
 352                         rte_socket_id());
 353                 if (test_params->p == NULL) {
 354                         printf("%s: Error creating mempool\n", __func__);
 355                         return -1;
 356                 }
 357         }
 358         return 0;
 359 }
 360
 361 static void
 362 test_teardown(void)
 363 {
 364         rte_reorder_free(test_params->b);
 365         test_params->b = NULL;
 366         rte_mempool_free(test_params->p);
 367         test_params->p = NULL;
 368 }
 369
 370
 371 static struct unit_test_suite reorder_test_suite  = {
 372
 373         .setup = test_setup,
 374         .teardown = test_teardown,
 375         .suite_name = "Reorder Unit Test Suite",
 376         .unit_test_cases = {
 377                 TEST_CASE(test_reorder_create),
 378                 TEST_CASE(test_reorder_init),
 379                 TEST_CASE(test_reorder_find_existing),
 380                 TEST_CASE(test_reorder_free),
 381                 TEST_CASE(test_reorder_insert),
 382                 TEST_CASE(test_reorder_drain),
 383                 TEST_CASES_END()
 384         }
 385 };
 386
 387 static int
 388 test_reorder(void)
 389 {
 390         return unit_test_suite_runner(&reorder_test_suite);
 391 }
 392
 393 REGISTER_TEST_COMMAND(reorder_autotest, test_reorder);