test/test/test_ring.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <string.h>
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <stdint.h>
  39 #include <inttypes.h>
  40 #include <errno.h>
  41 #include <sys/queue.h>
  42
  43 #include <rte_common.h>
  44 #include <rte_log.h>
  45 #include <rte_memory.h>
  46 #include <rte_memzone.h>
  47 #include <rte_launch.h>
  48 #include <rte_cycles.h>
  49 #include <rte_eal.h>
  50 #include <rte_per_lcore.h>
  51 #include <rte_lcore.h>
  52 #include <rte_atomic.h>
  53 #include <rte_branch_prediction.h>
  54 #include <rte_malloc.h>
  55 #include <rte_ring.h>
  56 #include <rte_random.h>
  57 #include <rte_common.h>
  58 #include <rte_errno.h>
  59 #include <rte_hexdump.h>
  60
  61 #include "test.h"
  62
  63 /*
  64  * Ring
  65  * ====
  66  *
  67  * #. Basic tests: done on one core:
  68  *
  69  *    - Using single producer/single consumer functions:
  70  *
  71  *      - Enqueue one object, two objects, MAX_BULK objects
  72  *      - Dequeue one object, two objects, MAX_BULK objects
  73  *      - Check that dequeued pointers are correct
  74  *
  75  *    - Using multi producers/multi consumers functions:
  76  *
  77  *      - Enqueue one object, two objects, MAX_BULK objects
  78  *      - Dequeue one object, two objects, MAX_BULK objects
  79  *      - Check that dequeued pointers are correct
  80  *
  81  * #. Performance tests.
  82  *
  83  * Tests done in test_ring_perf.c
  84  */
  85
  86 #define RING_SIZE 4096
  87 #define MAX_BULK 32
  88
  89 static rte_atomic32_t synchro;
  90
  91 static struct rte_ring *r;
  92
  93 #define TEST_RING_VERIFY(exp)                                           \
  94         if (!(exp)) {                                                   \
  95                 printf("error at %s:%d\tcondition " #exp " failed\n",   \
  96                     __func__, __LINE__);                                \
  97                 rte_ring_dump(stdout, r);                               \
  98                 return -1;                                              \
  99         }
 100
 101 #define TEST_RING_FULL_EMTPY_ITER       8
 102
 103 /*
 104  * helper routine for test_ring_basic
 105  */
 106 static int
 107 test_ring_basic_full_empty(void * const src[], void *dst[])
 108 {
 109         unsigned i, rand;
 110         const unsigned rsz = RING_SIZE - 1;
 111
 112         printf("Basic full/empty test\n");
 113
 114         for (i = 0; TEST_RING_FULL_EMTPY_ITER != i; i++) {
 115
 116                 /* random shift in the ring */
 117                 rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 118                 printf("%s: iteration %u, random shift: %u;\n",
 119                     __func__, i, rand);
 120                 TEST_RING_VERIFY(rte_ring_enqueue_bulk(r, src, rand) != 0);
 121                 TEST_RING_VERIFY(rte_ring_dequeue_bulk(r, dst, rand) == rand);
 122
 123                 /* fill the ring */
 124                 TEST_RING_VERIFY(rte_ring_enqueue_bulk(r, src, rsz) != 0);
 125                 TEST_RING_VERIFY(0 == rte_ring_free_count(r));
 126                 TEST_RING_VERIFY(rsz == rte_ring_count(r));
 127                 TEST_RING_VERIFY(rte_ring_full(r));
 128                 TEST_RING_VERIFY(0 == rte_ring_empty(r));
 129
 130                 /* empty the ring */
 131                 TEST_RING_VERIFY(rte_ring_dequeue_bulk(r, dst, rsz) == rsz);
 132                 TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
 133                 TEST_RING_VERIFY(0 == rte_ring_count(r));
 134                 TEST_RING_VERIFY(0 == rte_ring_full(r));
 135                 TEST_RING_VERIFY(rte_ring_empty(r));
 136
 137                 /* check data */
 138                 TEST_RING_VERIFY(0 == memcmp(src, dst, rsz));
 139                 rte_ring_dump(stdout, r);
 140         }
 141         return 0;
 142 }
 143
 144 static int
 145 test_ring_basic(void)
 146 {
 147         void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 148         int ret;
 149         unsigned i, num_elems;
 150
 151         /* alloc dummy object pointers */
 152         src = malloc(RING_SIZE*2*sizeof(void *));
 153         if (src == NULL)
 154                 goto fail;
 155
 156         for (i = 0; i < RING_SIZE*2 ; i++) {
 157                 src[i] = (void *)(unsigned long)i;
 158         }
 159         cur_src = src;
 160
 161         /* alloc some room for copied objects */
 162         dst = malloc(RING_SIZE*2*sizeof(void *));
 163         if (dst == NULL)
 164                 goto fail;
 165
 166         memset(dst, 0, RING_SIZE*2*sizeof(void *));
 167         cur_dst = dst;
 168
 169         printf("enqueue 1 obj\n");
 170         ret = rte_ring_sp_enqueue_bulk(r, cur_src, 1);
 171         cur_src += 1;
 172         if (ret == 0)
 173                 goto fail;
 174
 175         printf("enqueue 2 objs\n");
 176         ret = rte_ring_sp_enqueue_bulk(r, cur_src, 2);
 177         cur_src += 2;
 178         if (ret == 0)
 179                 goto fail;
 180
 181         printf("enqueue MAX_BULK objs\n");
 182         ret = rte_ring_sp_enqueue_bulk(r, cur_src, MAX_BULK);
 183         cur_src += MAX_BULK;
 184         if (ret == 0)
 185                 goto fail;
 186
 187         printf("dequeue 1 obj\n");
 188         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 1);
 189         cur_dst += 1;
 190         if (ret == 0)
 191                 goto fail;
 192
 193         printf("dequeue 2 objs\n");
 194         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 2);
 195         cur_dst += 2;
 196         if (ret == 0)
 197                 goto fail;
 198
 199         printf("dequeue MAX_BULK objs\n");
 200         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, MAX_BULK);
 201         cur_dst += MAX_BULK;
 202         if (ret == 0)
 203                 goto fail;
 204
 205         /* check data */
 206         if (memcmp(src, dst, cur_dst - dst)) {
 207                 rte_hexdump(stdout, "src", src, cur_src - src);
 208                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 209                 printf("data after dequeue is not the same\n");
 210                 goto fail;
 211         }
 212         cur_src = src;
 213         cur_dst = dst;
 214
 215         printf("enqueue 1 obj\n");
 216         ret = rte_ring_mp_enqueue_bulk(r, cur_src, 1);
 217         cur_src += 1;
 218         if (ret == 0)
 219                 goto fail;
 220
 221         printf("enqueue 2 objs\n");
 222         ret = rte_ring_mp_enqueue_bulk(r, cur_src, 2);
 223         cur_src += 2;
 224         if (ret == 0)
 225                 goto fail;
 226
 227         printf("enqueue MAX_BULK objs\n");
 228         ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
 229         cur_src += MAX_BULK;
 230         if (ret == 0)
 231                 goto fail;
 232
 233         printf("dequeue 1 obj\n");
 234         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 1);
 235         cur_dst += 1;
 236         if (ret == 0)
 237                 goto fail;
 238
 239         printf("dequeue 2 objs\n");
 240         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 2);
 241         cur_dst += 2;
 242         if (ret == 0)
 243                 goto fail;
 244
 245         printf("dequeue MAX_BULK objs\n");
 246         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
 247         cur_dst += MAX_BULK;
 248         if (ret == 0)
 249                 goto fail;
 250
 251         /* check data */
 252         if (memcmp(src, dst, cur_dst - dst)) {
 253                 rte_hexdump(stdout, "src", src, cur_src - src);
 254                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 255                 printf("data after dequeue is not the same\n");
 256                 goto fail;
 257         }
 258         cur_src = src;
 259         cur_dst = dst;
 260
 261         printf("fill and empty the ring\n");
 262         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
 263                 ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
 264                 cur_src += MAX_BULK;
 265                 if (ret == 0)
 266                         goto fail;
 267                 ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
 268                 cur_dst += MAX_BULK;
 269                 if (ret == 0)
 270                         goto fail;
 271         }
 272
 273         /* check data */
 274         if (memcmp(src, dst, cur_dst - dst)) {
 275                 rte_hexdump(stdout, "src", src, cur_src - src);
 276                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 277                 printf("data after dequeue is not the same\n");
 278                 goto fail;
 279         }
 280
 281         if (test_ring_basic_full_empty(src, dst) != 0)
 282                 goto fail;
 283
 284         cur_src = src;
 285         cur_dst = dst;
 286
 287         printf("test default bulk enqueue / dequeue\n");
 288         num_elems = 16;
 289
 290         cur_src = src;
 291         cur_dst = dst;
 292
 293         ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
 294         cur_src += num_elems;
 295         if (ret == 0) {
 296                 printf("Cannot enqueue\n");
 297                 goto fail;
 298         }
 299         ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
 300         cur_src += num_elems;
 301         if (ret == 0) {
 302                 printf("Cannot enqueue\n");
 303                 goto fail;
 304         }
 305         ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
 306         cur_dst += num_elems;
 307         if (ret == 0) {
 308                 printf("Cannot dequeue\n");
 309                 goto fail;
 310         }
 311         ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
 312         cur_dst += num_elems;
 313         if (ret == 0) {
 314                 printf("Cannot dequeue2\n");
 315                 goto fail;
 316         }
 317
 318         /* check data */
 319         if (memcmp(src, dst, cur_dst - dst)) {
 320                 rte_hexdump(stdout, "src", src, cur_src - src);
 321                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 322                 printf("data after dequeue is not the same\n");
 323                 goto fail;
 324         }
 325
 326         cur_src = src;
 327         cur_dst = dst;
 328
 329         ret = rte_ring_mp_enqueue(r, cur_src);
 330         if (ret != 0)
 331                 goto fail;
 332
 333         ret = rte_ring_mc_dequeue(r, cur_dst);
 334         if (ret != 0)
 335                 goto fail;
 336
 337         free(src);
 338         free(dst);
 339         return 0;
 340
 341  fail:
 342         free(src);
 343         free(dst);
 344         return -1;
 345 }
 346
 347 static int
 348 test_ring_burst_basic(void)
 349 {
 350         void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 351         int ret;
 352         unsigned i;
 353
 354         /* alloc dummy object pointers */
 355         src = malloc(RING_SIZE*2*sizeof(void *));
 356         if (src == NULL)
 357                 goto fail;
 358
 359         for (i = 0; i < RING_SIZE*2 ; i++) {
 360                 src[i] = (void *)(unsigned long)i;
 361         }
 362         cur_src = src;
 363
 364         /* alloc some room for copied objects */
 365         dst = malloc(RING_SIZE*2*sizeof(void *));
 366         if (dst == NULL)
 367                 goto fail;
 368
 369         memset(dst, 0, RING_SIZE*2*sizeof(void *));
 370         cur_dst = dst;
 371
 372         printf("Test SP & SC basic functions \n");
 373         printf("enqueue 1 obj\n");
 374         ret = rte_ring_sp_enqueue_burst(r, cur_src, 1);
 375         cur_src += 1;
 376         if ((ret & RTE_RING_SZ_MASK) != 1)
 377                 goto fail;
 378
 379         printf("enqueue 2 objs\n");
 380         ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
 381         cur_src += 2;
 382         if ((ret & RTE_RING_SZ_MASK) != 2)
 383                 goto fail;
 384
 385         printf("enqueue MAX_BULK objs\n");
 386         ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK) ;
 387         cur_src += MAX_BULK;
 388         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 389                 goto fail;
 390
 391         printf("dequeue 1 obj\n");
 392         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 1) ;
 393         cur_dst += 1;
 394         if ((ret & RTE_RING_SZ_MASK) != 1)
 395                 goto fail;
 396
 397         printf("dequeue 2 objs\n");
 398         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
 399         cur_dst += 2;
 400         if ((ret & RTE_RING_SZ_MASK) != 2)
 401                 goto fail;
 402
 403         printf("dequeue MAX_BULK objs\n");
 404         ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 405         cur_dst += MAX_BULK;
 406         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 407                 goto fail;
 408
 409         /* check data */
 410         if (memcmp(src, dst, cur_dst - dst)) {
 411                 rte_hexdump(stdout, "src", src, cur_src - src);
 412                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 413                 printf("data after dequeue is not the same\n");
 414                 goto fail;
 415         }
 416
 417         cur_src = src;
 418         cur_dst = dst;
 419
 420         printf("Test enqueue without enough memory space \n");
 421         for (i = 0; i< (RING_SIZE/MAX_BULK - 1); i++) {
 422                 ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 423                 cur_src += MAX_BULK;
 424                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK) {
 425                         goto fail;
 426                 }
 427         }
 428
 429         printf("Enqueue 2 objects, free entries = MAX_BULK - 2  \n");
 430         ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
 431         cur_src += 2;
 432         if ((ret & RTE_RING_SZ_MASK) != 2)
 433                 goto fail;
 434
 435         printf("Enqueue the remaining entries = MAX_BULK - 2  \n");
 436         /* Always one free entry left */
 437         ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 438         cur_src += MAX_BULK - 3;
 439         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 440                 goto fail;
 441
 442         printf("Test if ring is full  \n");
 443         if (rte_ring_full(r) != 1)
 444                 goto fail;
 445
 446         printf("Test enqueue for a full entry  \n");
 447         ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 448         if ((ret & RTE_RING_SZ_MASK) != 0)
 449                 goto fail;
 450
 451         printf("Test dequeue without enough objects \n");
 452         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 453                 ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 454                 cur_dst += MAX_BULK;
 455                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 456                         goto fail;
 457         }
 458
 459         /* Available memory space for the exact MAX_BULK entries */
 460         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
 461         cur_dst += 2;
 462         if ((ret & RTE_RING_SZ_MASK) != 2)
 463                 goto fail;
 464
 465         ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 466         cur_dst += MAX_BULK - 3;
 467         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 468                 goto fail;
 469
 470         printf("Test if ring is empty \n");
 471         /* Check if ring is empty */
 472         if (1 != rte_ring_empty(r))
 473                 goto fail;
 474
 475         /* check data */
 476         if (memcmp(src, dst, cur_dst - dst)) {
 477                 rte_hexdump(stdout, "src", src, cur_src - src);
 478                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 479                 printf("data after dequeue is not the same\n");
 480                 goto fail;
 481         }
 482
 483         cur_src = src;
 484         cur_dst = dst;
 485
 486         printf("Test MP & MC basic functions \n");
 487
 488         printf("enqueue 1 obj\n");
 489         ret = rte_ring_mp_enqueue_burst(r, cur_src, 1);
 490         cur_src += 1;
 491         if ((ret & RTE_RING_SZ_MASK) != 1)
 492                 goto fail;
 493
 494         printf("enqueue 2 objs\n");
 495         ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
 496         cur_src += 2;
 497         if ((ret & RTE_RING_SZ_MASK) != 2)
 498                 goto fail;
 499
 500         printf("enqueue MAX_BULK objs\n");
 501         ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 502         cur_src += MAX_BULK;
 503         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 504                 goto fail;
 505
 506         printf("dequeue 1 obj\n");
 507         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 1);
 508         cur_dst += 1;
 509         if ((ret & RTE_RING_SZ_MASK) != 1)
 510                 goto fail;
 511
 512         printf("dequeue 2 objs\n");
 513         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
 514         cur_dst += 2;
 515         if ((ret & RTE_RING_SZ_MASK) != 2)
 516                 goto fail;
 517
 518         printf("dequeue MAX_BULK objs\n");
 519         ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 520         cur_dst += MAX_BULK;
 521         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 522                 goto fail;
 523
 524         /* check data */
 525         if (memcmp(src, dst, cur_dst - dst)) {
 526                 rte_hexdump(stdout, "src", src, cur_src - src);
 527                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 528                 printf("data after dequeue is not the same\n");
 529                 goto fail;
 530         }
 531
 532         cur_src = src;
 533         cur_dst = dst;
 534
 535         printf("fill and empty the ring\n");
 536         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
 537                 ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 538                 cur_src += MAX_BULK;
 539                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 540                         goto fail;
 541                 ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 542                 cur_dst += MAX_BULK;
 543                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 544                         goto fail;
 545         }
 546
 547         /* check data */
 548         if (memcmp(src, dst, cur_dst - dst)) {
 549                 rte_hexdump(stdout, "src", src, cur_src - src);
 550                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 551                 printf("data after dequeue is not the same\n");
 552                 goto fail;
 553         }
 554
 555         cur_src = src;
 556         cur_dst = dst;
 557
 558         printf("Test enqueue without enough memory space \n");
 559         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 560                 ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 561                 cur_src += MAX_BULK;
 562                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 563                         goto fail;
 564         }
 565
 566         /* Available memory space for the exact MAX_BULK objects */
 567         ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
 568         cur_src += 2;
 569         if ((ret & RTE_RING_SZ_MASK) != 2)
 570                 goto fail;
 571
 572         ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 573         cur_src += MAX_BULK - 3;
 574         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 575                 goto fail;
 576
 577
 578         printf("Test dequeue without enough objects \n");
 579         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 580                 ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 581                 cur_dst += MAX_BULK;
 582                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 583                         goto fail;
 584         }
 585
 586         /* Available objects - the exact MAX_BULK */
 587         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
 588         cur_dst += 2;
 589         if ((ret & RTE_RING_SZ_MASK) != 2)
 590                 goto fail;
 591
 592         ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 593         cur_dst += MAX_BULK - 3;
 594         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 595                 goto fail;
 596
 597         /* check data */
 598         if (memcmp(src, dst, cur_dst - dst)) {
 599                 rte_hexdump(stdout, "src", src, cur_src - src);
 600                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 601                 printf("data after dequeue is not the same\n");
 602                 goto fail;
 603         }
 604
 605         cur_src = src;
 606         cur_dst = dst;
 607
 608         printf("Covering rte_ring_enqueue_burst functions \n");
 609
 610         ret = rte_ring_enqueue_burst(r, cur_src, 2);
 611         cur_src += 2;
 612         if ((ret & RTE_RING_SZ_MASK) != 2)
 613                 goto fail;
 614
 615         ret = rte_ring_dequeue_burst(r, cur_dst, 2);
 616         cur_dst += 2;
 617         if (ret != 2)
 618                 goto fail;
 619
 620         /* Free memory before test completed */
 621         free(src);
 622         free(dst);
 623         return 0;
 624
 625  fail:
 626         free(src);
 627         free(dst);
 628         return -1;
 629 }
 630
 631 /*
 632  * it will always fail to create ring with a wrong ring size number in this function
 633  */
 634 static int
 635 test_ring_creation_with_wrong_size(void)
 636 {
 637         struct rte_ring * rp = NULL;
 638
 639         /* Test if ring size is not power of 2 */
 640         rp = rte_ring_create("test_bad_ring_size", RING_SIZE + 1, SOCKET_ID_ANY, 0);
 641         if (NULL != rp) {
 642                 return -1;
 643         }
 644
 645         /* Test if ring size is exceeding the limit */
 646         rp = rte_ring_create("test_bad_ring_size", (RTE_RING_SZ_MASK + 1), SOCKET_ID_ANY, 0);
 647         if (NULL != rp) {
 648                 return -1;
 649         }
 650         return 0;
 651 }
 652
 653 /*
 654  * it tests if it would always fail to create ring with an used ring name
 655  */
 656 static int
 657 test_ring_creation_with_an_used_name(void)
 658 {
 659         struct rte_ring * rp;
 660
 661         rp = rte_ring_create("test", RING_SIZE, SOCKET_ID_ANY, 0);
 662         if (NULL != rp)
 663                 return -1;
 664
 665         return 0;
 666 }
 667
 668 /*
 669  * Test to if a non-power of 2 count causes the create
 670  * function to fail correctly
 671  */
 672 static int
 673 test_create_count_odd(void)
 674 {
 675         struct rte_ring *r = rte_ring_create("test_ring_count",
 676                         4097, SOCKET_ID_ANY, 0 );
 677         if(r != NULL){
 678                 return -1;
 679         }
 680         return 0;
 681 }
 682
 683 static int
 684 test_lookup_null(void)
 685 {
 686         struct rte_ring *rlp = rte_ring_lookup("ring_not_found");
 687         if (rlp ==NULL)
 688         if (rte_errno != ENOENT){
 689                 printf( "test failed to returnn error on null pointer\n");
 690                 return -1;
 691         }
 692         return 0;
 693 }
 694
 695 /*
 696  * it tests some more basic ring operations
 697  */
 698 static int
 699 test_ring_basic_ex(void)
 700 {
 701         int ret = -1;
 702         unsigned i;
 703         struct rte_ring * rp;
 704         void **obj = NULL;
 705
 706         obj = rte_calloc("test_ring_basic_ex_malloc", RING_SIZE, sizeof(void *), 0);
 707         if (obj == NULL) {
 708                 printf("test_ring_basic_ex fail to rte_malloc\n");
 709                 goto fail_test;
 710         }
 711
 712         rp = rte_ring_create("test_ring_basic_ex", RING_SIZE, SOCKET_ID_ANY,
 713                         RING_F_SP_ENQ | RING_F_SC_DEQ);
 714         if (rp == NULL) {
 715                 printf("test_ring_basic_ex fail to create ring\n");
 716                 goto fail_test;
 717         }
 718
 719         if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 720                 goto fail_test;
 721         }
 722
 723         if (rte_ring_empty(rp) != 1) {
 724                 printf("test_ring_basic_ex ring is not empty but it should be\n");
 725                 goto fail_test;
 726         }
 727
 728         printf("%u ring entries are now free\n", rte_ring_free_count(rp));
 729
 730         for (i = 0; i < RING_SIZE; i ++) {
 731                 rte_ring_enqueue(rp, obj[i]);
 732         }
 733
 734         if (rte_ring_full(rp) != 1) {
 735                 printf("test_ring_basic_ex ring is not full but it should be\n");
 736                 goto fail_test;
 737         }
 738
 739         for (i = 0; i < RING_SIZE; i ++) {
 740                 rte_ring_dequeue(rp, &obj[i]);
 741         }
 742
 743         if (rte_ring_empty(rp) != 1) {
 744                 printf("test_ring_basic_ex ring is not empty but it should be\n");
 745                 goto fail_test;
 746         }
 747
 748         /* Covering the ring burst operation */
 749         ret = rte_ring_enqueue_burst(rp, obj, 2);
 750         if ((ret & RTE_RING_SZ_MASK) != 2) {
 751                 printf("test_ring_basic_ex: rte_ring_enqueue_burst fails \n");
 752                 goto fail_test;
 753         }
 754
 755         ret = rte_ring_dequeue_burst(rp, obj, 2);
 756         if (ret != 2) {
 757                 printf("test_ring_basic_ex: rte_ring_dequeue_burst fails \n");
 758                 goto fail_test;
 759         }
 760
 761         ret = 0;
 762 fail_test:
 763         if (obj != NULL)
 764                 rte_free(obj);
 765
 766         return ret;
 767 }
 768
 769 static int
 770 test_ring(void)
 771 {
 772         /* some more basic operations */
 773         if (test_ring_basic_ex() < 0)
 774                 return -1;
 775
 776         rte_atomic32_init(&synchro);
 777
 778         if (r == NULL)
 779                 r = rte_ring_create("test", RING_SIZE, SOCKET_ID_ANY, 0);
 780         if (r == NULL)
 781                 return -1;
 782
 783         /* retrieve the ring from its name */
 784         if (rte_ring_lookup("test") != r) {
 785                 printf("Cannot lookup ring from its name\n");
 786                 return -1;
 787         }
 788
 789         /* burst operations */
 790         if (test_ring_burst_basic() < 0)
 791                 return -1;
 792
 793         /* basic operations */
 794         if (test_ring_basic() < 0)
 795                 return -1;
 796
 797         /* basic operations */
 798         if ( test_create_count_odd() < 0){
 799                         printf ("Test failed to detect odd count\n");
 800                         return -1;
 801                 }
 802                 else
 803                         printf ( "Test detected odd count\n");
 804
 805         if ( test_lookup_null() < 0){
 806                                 printf ("Test failed to detect NULL ring lookup\n");
 807                                 return -1;
 808                         }
 809                         else
 810                                 printf ( "Test detected NULL ring lookup \n");
 811
 812         /* test of creating ring with wrong size */
 813         if (test_ring_creation_with_wrong_size() < 0)
 814                 return -1;
 815
 816         /* test of creation ring with an used name */
 817         if (test_ring_creation_with_an_used_name() < 0)
 818                 return -1;
 819
 820         /* dump the ring status */
 821         rte_ring_list_dump(stdout);
 822
 823         return 0;
 824 }
 825
 826 REGISTER_TEST_COMMAND(ring_autotest, test_ring);