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  *    - Test watermark and default bulk enqueue/dequeue:
  82  *
  83  *      - Set watermark
  84  *      - Set default bulk value
  85  *      - Enqueue objects, check that -EDQUOT is returned when
  86  *        watermark is exceeded
  87  *      - Check that dequeued pointers are correct
  88  *
  89  * #. Check live watermark change
  90  *
  91  *    - Start a loop on another lcore that will enqueue and dequeue
  92  *      objects in a ring. It will monitor the value of watermark.
  93  *    - At the same time, change the watermark on the master lcore.
  94  *    - The slave lcore will check that watermark changes from 16 to 32.
  95  *
  96  * #. Performance tests.
  97  *
  98  * Tests done in test_ring_perf.c
  99  */
 100
 101 #define RING_SIZE 4096
 102 #define MAX_BULK 32
 103
 104 static rte_atomic32_t synchro;
 105
 106 static struct rte_ring *r;
 107
 108 #define TEST_RING_VERIFY(exp)                                           \
 109         if (!(exp)) {                                                   \
 110                 printf("error at %s:%d\tcondition " #exp " failed\n",   \
 111                     __func__, __LINE__);                                \
 112                 rte_ring_dump(stdout, r);                               \
 113                 return -1;                                              \
 114         }
 115
 116 #define TEST_RING_FULL_EMTPY_ITER       8
 117
 118 static int
 119 check_live_watermark_change(__attribute__((unused)) void *dummy)
 120 {
 121         uint64_t hz = rte_get_timer_hz();
 122         void *obj_table[MAX_BULK];
 123         unsigned watermark, watermark_old = 16;
 124         uint64_t cur_time, end_time;
 125         int64_t diff = 0;
 126         int i, ret;
 127         unsigned count = 4;
 128
 129         /* init the object table */
 130         memset(obj_table, 0, sizeof(obj_table));
 131         end_time = rte_get_timer_cycles() + (hz / 4);
 132
 133         /* check that bulk and watermark are 4 and 32 (respectively) */
 134         while (diff >= 0) {
 135
 136                 /* add in ring until we reach watermark */
 137                 ret = 0;
 138                 for (i = 0; i < 16; i ++) {
 139                         if (ret != 0)
 140                                 break;
 141                         ret = rte_ring_enqueue_bulk(r, obj_table, count);
 142                 }
 143
 144                 if (ret != -EDQUOT) {
 145                         printf("Cannot enqueue objects, or watermark not "
 146                                "reached (ret=%d)\n", ret);
 147                         return -1;
 148                 }
 149
 150                 /* read watermark, the only change allowed is from 16 to 32 */
 151                 watermark = r->prod.watermark;
 152                 if (watermark != watermark_old &&
 153                     (watermark_old != 16 || watermark != 32)) {
 154                         printf("Bad watermark change %u -> %u\n", watermark_old,
 155                                watermark);
 156                         return -1;
 157                 }
 158                 watermark_old = watermark;
 159
 160                 /* dequeue objects from ring */
 161                 while (i--) {
 162                         ret = rte_ring_dequeue_bulk(r, obj_table, count);
 163                         if (ret != 0) {
 164                                 printf("Cannot dequeue (ret=%d)\n", ret);
 165                                 return -1;
 166                         }
 167                 }
 168
 169                 cur_time = rte_get_timer_cycles();
 170                 diff = end_time - cur_time;
 171         }
 172
 173         if (watermark_old != 32 ) {
 174                 printf(" watermark was not updated (wm=%u)\n",
 175                        watermark_old);
 176                 return -1;
 177         }
 178
 179         return 0;
 180 }
 181
 182 static int
 183 test_live_watermark_change(void)
 184 {
 185         unsigned lcore_id = rte_lcore_id();
 186         unsigned lcore_id2 = rte_get_next_lcore(lcore_id, 0, 1);
 187
 188         printf("Test watermark live modification\n");
 189         rte_ring_set_water_mark(r, 16);
 190
 191         /* launch a thread that will enqueue and dequeue, checking
 192          * watermark and quota */
 193         rte_eal_remote_launch(check_live_watermark_change, NULL, lcore_id2);
 194
 195         rte_delay_ms(100);
 196         rte_ring_set_water_mark(r, 32);
 197         rte_delay_ms(100);
 198
 199         if (rte_eal_wait_lcore(lcore_id2) < 0)
 200                 return -1;
 201
 202         return 0;
 203 }
 204
 205 /* Test for catch on invalid watermark values */
 206 static int
 207 test_set_watermark( void ){
 208         unsigned count;
 209         int setwm;
 210
 211         struct rte_ring *r = rte_ring_lookup("test_ring_basic_ex");
 212         if(r == NULL){
 213                 printf( " ring lookup failed\n" );
 214                 goto error;
 215         }
 216         count = r->prod.size*2;
 217         setwm = rte_ring_set_water_mark(r, count);
 218         if (setwm != -EINVAL){
 219                 printf("Test failed to detect invalid watermark count value\n");
 220                 goto error;
 221         }
 222
 223         count = 0;
 224         rte_ring_set_water_mark(r, count);
 225         if (r->prod.watermark != r->prod.size) {
 226                 printf("Test failed to detect invalid watermark count value\n");
 227                 goto error;
 228         }
 229         return 0;
 230
 231 error:
 232         return -1;
 233 }
 234
 235 /*
 236  * helper routine for test_ring_basic
 237  */
 238 static int
 239 test_ring_basic_full_empty(void * const src[], void *dst[])
 240 {
 241         unsigned i, rand;
 242         const unsigned rsz = RING_SIZE - 1;
 243
 244         printf("Basic full/empty test\n");
 245
 246         for (i = 0; TEST_RING_FULL_EMTPY_ITER != i; i++) {
 247
 248                 /* random shift in the ring */
 249                 rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 250                 printf("%s: iteration %u, random shift: %u;\n",
 251                     __func__, i, rand);
 252                 TEST_RING_VERIFY(-ENOBUFS != rte_ring_enqueue_bulk(r, src,
 253                     rand));
 254                 TEST_RING_VERIFY(0 == rte_ring_dequeue_bulk(r, dst, rand));
 255
 256                 /* fill the ring */
 257                 TEST_RING_VERIFY(-ENOBUFS != rte_ring_enqueue_bulk(r, src,
 258                     rsz));
 259                 TEST_RING_VERIFY(0 == rte_ring_free_count(r));
 260                 TEST_RING_VERIFY(rsz == rte_ring_count(r));
 261                 TEST_RING_VERIFY(rte_ring_full(r));
 262                 TEST_RING_VERIFY(0 == rte_ring_empty(r));
 263
 264                 /* empty the ring */
 265                 TEST_RING_VERIFY(0 == rte_ring_dequeue_bulk(r, dst, rsz));
 266                 TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
 267                 TEST_RING_VERIFY(0 == rte_ring_count(r));
 268                 TEST_RING_VERIFY(0 == rte_ring_full(r));
 269                 TEST_RING_VERIFY(rte_ring_empty(r));
 270
 271                 /* check data */
 272                 TEST_RING_VERIFY(0 == memcmp(src, dst, rsz));
 273                 rte_ring_dump(stdout, r);
 274         }
 275         return 0;
 276 }
 277
 278 static int
 279 test_ring_basic(void)
 280 {
 281         void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 282         int ret;
 283         unsigned i, num_elems;
 284
 285         /* alloc dummy object pointers */
 286         src = malloc(RING_SIZE*2*sizeof(void *));
 287         if (src == NULL)
 288                 goto fail;
 289
 290         for (i = 0; i < RING_SIZE*2 ; i++) {
 291                 src[i] = (void *)(unsigned long)i;
 292         }
 293         cur_src = src;
 294
 295         /* alloc some room for copied objects */
 296         dst = malloc(RING_SIZE*2*sizeof(void *));
 297         if (dst == NULL)
 298                 goto fail;
 299
 300         memset(dst, 0, RING_SIZE*2*sizeof(void *));
 301         cur_dst = dst;
 302
 303         printf("enqueue 1 obj\n");
 304         ret = rte_ring_sp_enqueue_bulk(r, cur_src, 1);
 305         cur_src += 1;
 306         if (ret != 0)
 307                 goto fail;
 308
 309         printf("enqueue 2 objs\n");
 310         ret = rte_ring_sp_enqueue_bulk(r, cur_src, 2);
 311         cur_src += 2;
 312         if (ret != 0)
 313                 goto fail;
 314
 315         printf("enqueue MAX_BULK objs\n");
 316         ret = rte_ring_sp_enqueue_bulk(r, cur_src, MAX_BULK);
 317         cur_src += MAX_BULK;
 318         if (ret != 0)
 319                 goto fail;
 320
 321         printf("dequeue 1 obj\n");
 322         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 1);
 323         cur_dst += 1;
 324         if (ret != 0)
 325                 goto fail;
 326
 327         printf("dequeue 2 objs\n");
 328         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 2);
 329         cur_dst += 2;
 330         if (ret != 0)
 331                 goto fail;
 332
 333         printf("dequeue MAX_BULK objs\n");
 334         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, MAX_BULK);
 335         cur_dst += MAX_BULK;
 336         if (ret != 0)
 337                 goto fail;
 338
 339         /* check data */
 340         if (memcmp(src, dst, cur_dst - dst)) {
 341                 rte_hexdump(stdout, "src", src, cur_src - src);
 342                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 343                 printf("data after dequeue is not the same\n");
 344                 goto fail;
 345         }
 346         cur_src = src;
 347         cur_dst = dst;
 348
 349         printf("enqueue 1 obj\n");
 350         ret = rte_ring_mp_enqueue_bulk(r, cur_src, 1);
 351         cur_src += 1;
 352         if (ret != 0)
 353                 goto fail;
 354
 355         printf("enqueue 2 objs\n");
 356         ret = rte_ring_mp_enqueue_bulk(r, cur_src, 2);
 357         cur_src += 2;
 358         if (ret != 0)
 359                 goto fail;
 360
 361         printf("enqueue MAX_BULK objs\n");
 362         ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
 363         cur_src += MAX_BULK;
 364         if (ret != 0)
 365                 goto fail;
 366
 367         printf("dequeue 1 obj\n");
 368         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 1);
 369         cur_dst += 1;
 370         if (ret != 0)
 371                 goto fail;
 372
 373         printf("dequeue 2 objs\n");
 374         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 2);
 375         cur_dst += 2;
 376         if (ret != 0)
 377                 goto fail;
 378
 379         printf("dequeue MAX_BULK objs\n");
 380         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
 381         cur_dst += MAX_BULK;
 382         if (ret != 0)
 383                 goto fail;
 384
 385         /* check data */
 386         if (memcmp(src, dst, cur_dst - dst)) {
 387                 rte_hexdump(stdout, "src", src, cur_src - src);
 388                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 389                 printf("data after dequeue is not the same\n");
 390                 goto fail;
 391         }
 392         cur_src = src;
 393         cur_dst = dst;
 394
 395         printf("fill and empty the ring\n");
 396         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
 397                 ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
 398                 cur_src += MAX_BULK;
 399                 if (ret != 0)
 400                         goto fail;
 401                 ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
 402                 cur_dst += MAX_BULK;
 403                 if (ret != 0)
 404                         goto fail;
 405         }
 406
 407         /* check data */
 408         if (memcmp(src, dst, cur_dst - dst)) {
 409                 rte_hexdump(stdout, "src", src, cur_src - src);
 410                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 411                 printf("data after dequeue is not the same\n");
 412                 goto fail;
 413         }
 414
 415         if (test_ring_basic_full_empty(src, dst) != 0)
 416                 goto fail;
 417
 418         cur_src = src;
 419         cur_dst = dst;
 420
 421         printf("test watermark and default bulk enqueue / dequeue\n");
 422         rte_ring_set_water_mark(r, 20);
 423         num_elems = 16;
 424
 425         cur_src = src;
 426         cur_dst = dst;
 427
 428         ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
 429         cur_src += num_elems;
 430         if (ret != 0) {
 431                 printf("Cannot enqueue\n");
 432                 goto fail;
 433         }
 434         ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
 435         cur_src += num_elems;
 436         if (ret != -EDQUOT) {
 437                 printf("Watermark not exceeded\n");
 438                 goto fail;
 439         }
 440         ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
 441         cur_dst += num_elems;
 442         if (ret != 0) {
 443                 printf("Cannot dequeue\n");
 444                 goto fail;
 445         }
 446         ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
 447         cur_dst += num_elems;
 448         if (ret != 0) {
 449                 printf("Cannot dequeue2\n");
 450                 goto fail;
 451         }
 452
 453         /* check data */
 454         if (memcmp(src, dst, cur_dst - dst)) {
 455                 rte_hexdump(stdout, "src", src, cur_src - src);
 456                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 457                 printf("data after dequeue is not the same\n");
 458                 goto fail;
 459         }
 460
 461         cur_src = src;
 462         cur_dst = dst;
 463
 464         ret = rte_ring_mp_enqueue(r, cur_src);
 465         if (ret != 0)
 466                 goto fail;
 467
 468         ret = rte_ring_mc_dequeue(r, cur_dst);
 469         if (ret != 0)
 470                 goto fail;
 471
 472         free(src);
 473         free(dst);
 474         return 0;
 475
 476  fail:
 477         free(src);
 478         free(dst);
 479         return -1;
 480 }
 481
 482 static int
 483 test_ring_burst_basic(void)
 484 {
 485         void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 486         int ret;
 487         unsigned i;
 488
 489         /* alloc dummy object pointers */
 490         src = malloc(RING_SIZE*2*sizeof(void *));
 491         if (src == NULL)
 492                 goto fail;
 493
 494         for (i = 0; i < RING_SIZE*2 ; i++) {
 495                 src[i] = (void *)(unsigned long)i;
 496         }
 497         cur_src = src;
 498
 499         /* alloc some room for copied objects */
 500         dst = malloc(RING_SIZE*2*sizeof(void *));
 501         if (dst == NULL)
 502                 goto fail;
 503
 504         memset(dst, 0, RING_SIZE*2*sizeof(void *));
 505         cur_dst = dst;
 506
 507         printf("Test SP & SC basic functions \n");
 508         printf("enqueue 1 obj\n");
 509         ret = rte_ring_sp_enqueue_burst(r, cur_src, 1);
 510         cur_src += 1;
 511         if ((ret & RTE_RING_SZ_MASK) != 1)
 512                 goto fail;
 513
 514         printf("enqueue 2 objs\n");
 515         ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
 516         cur_src += 2;
 517         if ((ret & RTE_RING_SZ_MASK) != 2)
 518                 goto fail;
 519
 520         printf("enqueue MAX_BULK objs\n");
 521         ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK) ;
 522         cur_src += MAX_BULK;
 523         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 524                 goto fail;
 525
 526         printf("dequeue 1 obj\n");
 527         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 1) ;
 528         cur_dst += 1;
 529         if ((ret & RTE_RING_SZ_MASK) != 1)
 530                 goto fail;
 531
 532         printf("dequeue 2 objs\n");
 533         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
 534         cur_dst += 2;
 535         if ((ret & RTE_RING_SZ_MASK) != 2)
 536                 goto fail;
 537
 538         printf("dequeue MAX_BULK objs\n");
 539         ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 540         cur_dst += MAX_BULK;
 541         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 542                 goto fail;
 543
 544         /* check data */
 545         if (memcmp(src, dst, cur_dst - dst)) {
 546                 rte_hexdump(stdout, "src", src, cur_src - src);
 547                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 548                 printf("data after dequeue is not the same\n");
 549                 goto fail;
 550         }
 551
 552         cur_src = src;
 553         cur_dst = dst;
 554
 555         printf("Test enqueue without enough memory space \n");
 556         for (i = 0; i< (RING_SIZE/MAX_BULK - 1); i++) {
 557                 ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 558                 cur_src += MAX_BULK;
 559                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK) {
 560                         goto fail;
 561                 }
 562         }
 563
 564         printf("Enqueue 2 objects, free entries = MAX_BULK - 2  \n");
 565         ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
 566         cur_src += 2;
 567         if ((ret & RTE_RING_SZ_MASK) != 2)
 568                 goto fail;
 569
 570         printf("Enqueue the remaining entries = MAX_BULK - 2  \n");
 571         /* Always one free entry left */
 572         ret = rte_ring_sp_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         printf("Test if ring is full  \n");
 578         if (rte_ring_full(r) != 1)
 579                 goto fail;
 580
 581         printf("Test enqueue for a full entry  \n");
 582         ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 583         if ((ret & RTE_RING_SZ_MASK) != 0)
 584                 goto fail;
 585
 586         printf("Test dequeue without enough objects \n");
 587         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 588                 ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 589                 cur_dst += MAX_BULK;
 590                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 591                         goto fail;
 592         }
 593
 594         /* Available memory space for the exact MAX_BULK entries */
 595         ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
 596         cur_dst += 2;
 597         if ((ret & RTE_RING_SZ_MASK) != 2)
 598                 goto fail;
 599
 600         ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 601         cur_dst += MAX_BULK - 3;
 602         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 603                 goto fail;
 604
 605         printf("Test if ring is empty \n");
 606         /* Check if ring is empty */
 607         if (1 != rte_ring_empty(r))
 608                 goto fail;
 609
 610         /* check data */
 611         if (memcmp(src, dst, cur_dst - dst)) {
 612                 rte_hexdump(stdout, "src", src, cur_src - src);
 613                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 614                 printf("data after dequeue is not the same\n");
 615                 goto fail;
 616         }
 617
 618         cur_src = src;
 619         cur_dst = dst;
 620
 621         printf("Test MP & MC basic functions \n");
 622
 623         printf("enqueue 1 obj\n");
 624         ret = rte_ring_mp_enqueue_burst(r, cur_src, 1);
 625         cur_src += 1;
 626         if ((ret & RTE_RING_SZ_MASK) != 1)
 627                 goto fail;
 628
 629         printf("enqueue 2 objs\n");
 630         ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
 631         cur_src += 2;
 632         if ((ret & RTE_RING_SZ_MASK) != 2)
 633                 goto fail;
 634
 635         printf("enqueue MAX_BULK objs\n");
 636         ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 637         cur_src += MAX_BULK;
 638         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 639                 goto fail;
 640
 641         printf("dequeue 1 obj\n");
 642         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 1);
 643         cur_dst += 1;
 644         if ((ret & RTE_RING_SZ_MASK) != 1)
 645                 goto fail;
 646
 647         printf("dequeue 2 objs\n");
 648         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
 649         cur_dst += 2;
 650         if ((ret & RTE_RING_SZ_MASK) != 2)
 651                 goto fail;
 652
 653         printf("dequeue MAX_BULK objs\n");
 654         ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 655         cur_dst += MAX_BULK;
 656         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 657                 goto fail;
 658
 659         /* check data */
 660         if (memcmp(src, dst, cur_dst - dst)) {
 661                 rte_hexdump(stdout, "src", src, cur_src - src);
 662                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 663                 printf("data after dequeue is not the same\n");
 664                 goto fail;
 665         }
 666
 667         cur_src = src;
 668         cur_dst = dst;
 669
 670         printf("fill and empty the ring\n");
 671         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
 672                 ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 673                 cur_src += MAX_BULK;
 674                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 675                         goto fail;
 676                 ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 677                 cur_dst += MAX_BULK;
 678                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 679                         goto fail;
 680         }
 681
 682         /* check data */
 683         if (memcmp(src, dst, cur_dst - dst)) {
 684                 rte_hexdump(stdout, "src", src, cur_src - src);
 685                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 686                 printf("data after dequeue is not the same\n");
 687                 goto fail;
 688         }
 689
 690         cur_src = src;
 691         cur_dst = dst;
 692
 693         printf("Test enqueue without enough memory space \n");
 694         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 695                 ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 696                 cur_src += MAX_BULK;
 697                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 698                         goto fail;
 699         }
 700
 701         /* Available memory space for the exact MAX_BULK objects */
 702         ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
 703         cur_src += 2;
 704         if ((ret & RTE_RING_SZ_MASK) != 2)
 705                 goto fail;
 706
 707         ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
 708         cur_src += MAX_BULK - 3;
 709         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 710                 goto fail;
 711
 712
 713         printf("Test dequeue without enough objects \n");
 714         for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
 715                 ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 716                 cur_dst += MAX_BULK;
 717                 if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
 718                         goto fail;
 719         }
 720
 721         /* Available objects - the exact MAX_BULK */
 722         ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
 723         cur_dst += 2;
 724         if ((ret & RTE_RING_SZ_MASK) != 2)
 725                 goto fail;
 726
 727         ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
 728         cur_dst += MAX_BULK - 3;
 729         if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
 730                 goto fail;
 731
 732         /* check data */
 733         if (memcmp(src, dst, cur_dst - dst)) {
 734                 rte_hexdump(stdout, "src", src, cur_src - src);
 735                 rte_hexdump(stdout, "dst", dst, cur_dst - dst);
 736                 printf("data after dequeue is not the same\n");
 737                 goto fail;
 738         }
 739
 740         cur_src = src;
 741         cur_dst = dst;
 742
 743         printf("Covering rte_ring_enqueue_burst functions \n");
 744
 745         ret = rte_ring_enqueue_burst(r, cur_src, 2);
 746         cur_src += 2;
 747         if ((ret & RTE_RING_SZ_MASK) != 2)
 748                 goto fail;
 749
 750         ret = rte_ring_dequeue_burst(r, cur_dst, 2);
 751         cur_dst += 2;
 752         if (ret != 2)
 753                 goto fail;
 754
 755         /* Free memory before test completed */
 756         free(src);
 757         free(dst);
 758         return 0;
 759
 760  fail:
 761         free(src);
 762         free(dst);
 763         return -1;
 764 }
 765
 766 static int
 767 test_ring_stats(void)
 768 {
 769
 770 #ifndef RTE_LIBRTE_RING_DEBUG
 771         printf("Enable RTE_LIBRTE_RING_DEBUG to test ring stats.\n");
 772         return 0;
 773 #else
 774         void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 775         int ret;
 776         unsigned i;
 777         unsigned num_items            = 0;
 778         unsigned failed_enqueue_ops   = 0;
 779         unsigned failed_enqueue_items = 0;
 780         unsigned failed_dequeue_ops   = 0;
 781         unsigned failed_dequeue_items = 0;
 782         unsigned last_enqueue_ops     = 0;
 783         unsigned last_enqueue_items   = 0;
 784         unsigned last_quota_ops       = 0;
 785         unsigned last_quota_items     = 0;
 786         unsigned lcore_id = rte_lcore_id();
 787         struct rte_ring_debug_stats *ring_stats = &r->stats[lcore_id];
 788
 789         printf("Test the ring stats.\n");
 790
 791         /* Reset the watermark in case it was set in another test. */
 792         rte_ring_set_water_mark(r, 0);
 793
 794         /* Reset the ring stats. */
 795         memset(&r->stats[lcore_id], 0, sizeof(r->stats[lcore_id]));
 796
 797         /* Allocate some dummy object pointers. */
 798         src = malloc(RING_SIZE*2*sizeof(void *));
 799         if (src == NULL)
 800                 goto fail;
 801
 802         for (i = 0; i < RING_SIZE*2 ; i++) {
 803                 src[i] = (void *)(unsigned long)i;
 804         }
 805
 806         /* Allocate some memory for copied objects. */
 807         dst = malloc(RING_SIZE*2*sizeof(void *));
 808         if (dst == NULL)
 809                 goto fail;
 810
 811         memset(dst, 0, RING_SIZE*2*sizeof(void *));
 812
 813         /* Set the head and tail pointers. */
 814         cur_src = src;
 815         cur_dst = dst;
 816
 817         /* Do Enqueue tests. */
 818         printf("Test the dequeue stats.\n");
 819
 820         /* Fill the ring up to RING_SIZE -1. */
 821         printf("Fill the ring.\n");
 822         for (i = 0; i< (RING_SIZE/MAX_BULK); i++) {
 823                 rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
 824                 cur_src += MAX_BULK;
 825         }
 826
 827         /* Adjust for final enqueue = MAX_BULK -1. */
 828         cur_src--;
 829
 830         printf("Verify that the ring is full.\n");
 831         if (rte_ring_full(r) != 1)
 832                 goto fail;
 833
 834
 835         printf("Verify the enqueue success stats.\n");
 836         /* Stats should match above enqueue operations to fill the ring. */
 837         if (ring_stats->enq_success_bulk != (RING_SIZE/MAX_BULK))
 838                 goto fail;
 839
 840         /* Current max objects is RING_SIZE -1. */
 841         if (ring_stats->enq_success_objs != RING_SIZE -1)
 842                 goto fail;
 843
 844         /* Shouldn't have any failures yet. */
 845         if (ring_stats->enq_fail_bulk != 0)
 846                 goto fail;
 847         if (ring_stats->enq_fail_objs != 0)
 848                 goto fail;
 849
 850
 851         printf("Test stats for SP burst enqueue to a full ring.\n");
 852         num_items = 2;
 853         ret = rte_ring_sp_enqueue_burst(r, cur_src, num_items);
 854         if ((ret & RTE_RING_SZ_MASK) != 0)
 855                 goto fail;
 856
 857         failed_enqueue_ops   += 1;
 858         failed_enqueue_items += num_items;
 859
 860         /* The enqueue should have failed. */
 861         if (ring_stats->enq_fail_bulk != failed_enqueue_ops)
 862                 goto fail;
 863         if (ring_stats->enq_fail_objs != failed_enqueue_items)
 864                 goto fail;
 865
 866
 867         printf("Test stats for SP bulk enqueue to a full ring.\n");
 868         num_items = 4;
 869         ret = rte_ring_sp_enqueue_bulk(r, cur_src, num_items);
 870         if (ret != -ENOBUFS)
 871                 goto fail;
 872
 873         failed_enqueue_ops   += 1;
 874         failed_enqueue_items += num_items;
 875
 876         /* The enqueue should have failed. */
 877         if (ring_stats->enq_fail_bulk != failed_enqueue_ops)
 878                 goto fail;
 879         if (ring_stats->enq_fail_objs != failed_enqueue_items)
 880                 goto fail;
 881
 882
 883         printf("Test stats for MP burst enqueue to a full ring.\n");
 884         num_items = 8;
 885         ret = rte_ring_mp_enqueue_burst(r, cur_src, num_items);
 886         if ((ret & RTE_RING_SZ_MASK) != 0)
 887                 goto fail;
 888
 889         failed_enqueue_ops   += 1;
 890         failed_enqueue_items += num_items;
 891
 892         /* The enqueue should have failed. */
 893         if (ring_stats->enq_fail_bulk != failed_enqueue_ops)
 894                 goto fail;
 895         if (ring_stats->enq_fail_objs != failed_enqueue_items)
 896                 goto fail;
 897
 898
 899         printf("Test stats for MP bulk enqueue to a full ring.\n");
 900         num_items = 16;
 901         ret = rte_ring_mp_enqueue_bulk(r, cur_src, num_items);
 902         if (ret != -ENOBUFS)
 903                 goto fail;
 904
 905         failed_enqueue_ops   += 1;
 906         failed_enqueue_items += num_items;
 907
 908         /* The enqueue should have failed. */
 909         if (ring_stats->enq_fail_bulk != failed_enqueue_ops)
 910                 goto fail;
 911         if (ring_stats->enq_fail_objs != failed_enqueue_items)
 912                 goto fail;
 913
 914
 915         /* Do Dequeue tests. */
 916         printf("Test the dequeue stats.\n");
 917
 918         printf("Empty the ring.\n");
 919         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
 920                 rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
 921                 cur_dst += MAX_BULK;
 922         }
 923
 924         /* There was only RING_SIZE -1 objects to dequeue. */
 925         cur_dst++;
 926
 927         printf("Verify ring is empty.\n");
 928         if (1 != rte_ring_empty(r))
 929                 goto fail;
 930
 931         printf("Verify the dequeue success stats.\n");
 932         /* Stats should match above dequeue operations. */
 933         if (ring_stats->deq_success_bulk != (RING_SIZE/MAX_BULK))
 934                 goto fail;
 935
 936         /* Objects dequeued is RING_SIZE -1. */
 937         if (ring_stats->deq_success_objs != RING_SIZE -1)
 938                 goto fail;
 939
 940         /* Shouldn't have any dequeue failure stats yet. */
 941         if (ring_stats->deq_fail_bulk != 0)
 942                 goto fail;
 943
 944         printf("Test stats for SC burst dequeue with an empty ring.\n");
 945         num_items = 2;
 946         ret = rte_ring_sc_dequeue_burst(r, cur_dst, num_items);
 947         if ((ret & RTE_RING_SZ_MASK) != 0)
 948                 goto fail;
 949
 950         failed_dequeue_ops   += 1;
 951         failed_dequeue_items += num_items;
 952
 953         /* The dequeue should have failed. */
 954         if (ring_stats->deq_fail_bulk != failed_dequeue_ops)
 955                 goto fail;
 956         if (ring_stats->deq_fail_objs != failed_dequeue_items)
 957                 goto fail;
 958
 959
 960         printf("Test stats for SC bulk dequeue with an empty ring.\n");
 961         num_items = 4;
 962         ret = rte_ring_sc_dequeue_bulk(r, cur_dst, num_items);
 963         if (ret != -ENOENT)
 964                 goto fail;
 965
 966         failed_dequeue_ops   += 1;
 967         failed_dequeue_items += num_items;
 968
 969         /* The dequeue should have failed. */
 970         if (ring_stats->deq_fail_bulk != failed_dequeue_ops)
 971                 goto fail;
 972         if (ring_stats->deq_fail_objs != failed_dequeue_items)
 973                 goto fail;
 974
 975
 976         printf("Test stats for MC burst dequeue with an empty ring.\n");
 977         num_items = 8;
 978         ret = rte_ring_mc_dequeue_burst(r, cur_dst, num_items);
 979         if ((ret & RTE_RING_SZ_MASK) != 0)
 980                 goto fail;
 981         failed_dequeue_ops   += 1;
 982         failed_dequeue_items += num_items;
 983
 984         /* The dequeue should have failed. */
 985         if (ring_stats->deq_fail_bulk != failed_dequeue_ops)
 986                 goto fail;
 987         if (ring_stats->deq_fail_objs != failed_dequeue_items)
 988                 goto fail;
 989
 990
 991         printf("Test stats for MC bulk dequeue with an empty ring.\n");
 992         num_items = 16;
 993         ret = rte_ring_mc_dequeue_bulk(r, cur_dst, num_items);
 994         if (ret != -ENOENT)
 995                 goto fail;
 996
 997         failed_dequeue_ops   += 1;
 998         failed_dequeue_items += num_items;
 999
1000         /* The dequeue should have failed. */
1001         if (ring_stats->deq_fail_bulk != failed_dequeue_ops)
1002                 goto fail;
1003         if (ring_stats->deq_fail_objs != failed_dequeue_items)
1004                 goto fail;
1005
1006
1007         printf("Test total enqueue/dequeue stats.\n");
1008         /* At this point the enqueue and dequeue stats should be the same. */
1009         if (ring_stats->enq_success_bulk != ring_stats->deq_success_bulk)
1010                 goto fail;
1011         if (ring_stats->enq_success_objs != ring_stats->deq_success_objs)
1012                 goto fail;
1013         if (ring_stats->enq_fail_bulk    != ring_stats->deq_fail_bulk)
1014                 goto fail;
1015         if (ring_stats->enq_fail_objs    != ring_stats->deq_fail_objs)
1016                 goto fail;
1017
1018
1019         /* Watermark Tests. */
1020         printf("Test the watermark/quota stats.\n");
1021
1022         printf("Verify the initial watermark stats.\n");
1023         /* Watermark stats should be 0 since there is no watermark. */
1024         if (ring_stats->enq_quota_bulk != 0)
1025                 goto fail;
1026         if (ring_stats->enq_quota_objs != 0)
1027                 goto fail;
1028
1029         /* Set a watermark. */
1030         rte_ring_set_water_mark(r, 16);
1031
1032         /* Reset pointers. */
1033         cur_src = src;
1034         cur_dst = dst;
1035
1036         last_enqueue_ops   = ring_stats->enq_success_bulk;
1037         last_enqueue_items = ring_stats->enq_success_objs;
1038
1039
1040         printf("Test stats for SP burst enqueue below watermark.\n");
1041         num_items = 8;
1042         ret = rte_ring_sp_enqueue_burst(r, cur_src, num_items);
1043         if ((ret & RTE_RING_SZ_MASK) != num_items)
1044                 goto fail;
1045
1046         /* Watermark stats should still be 0. */
1047         if (ring_stats->enq_quota_bulk != 0)
1048                 goto fail;
1049         if (ring_stats->enq_quota_objs != 0)
1050                 goto fail;
1051
1052         /* Success stats should have increased. */
1053         if (ring_stats->enq_success_bulk != last_enqueue_ops + 1)
1054                 goto fail;
1055         if (ring_stats->enq_success_objs != last_enqueue_items + num_items)
1056                 goto fail;
1057
1058         last_enqueue_ops   = ring_stats->enq_success_bulk;
1059         last_enqueue_items = ring_stats->enq_success_objs;
1060
1061
1062         printf("Test stats for SP burst enqueue at watermark.\n");
1063         num_items = 8;
1064         ret = rte_ring_sp_enqueue_burst(r, cur_src, num_items);
1065         if ((ret & RTE_RING_SZ_MASK) != num_items)
1066                 goto fail;
1067
1068         /* Watermark stats should have changed. */
1069         if (ring_stats->enq_quota_bulk != 1)
1070                 goto fail;
1071         if (ring_stats->enq_quota_objs != num_items)
1072                 goto fail;
1073
1074         last_quota_ops   = ring_stats->enq_quota_bulk;
1075         last_quota_items = ring_stats->enq_quota_objs;
1076
1077
1078         printf("Test stats for SP burst enqueue above watermark.\n");
1079         num_items = 1;
1080         ret = rte_ring_sp_enqueue_burst(r, cur_src, num_items);
1081         if ((ret & RTE_RING_SZ_MASK) != num_items)
1082                 goto fail;
1083
1084         /* Watermark stats should have changed. */
1085         if (ring_stats->enq_quota_bulk != last_quota_ops +1)
1086                 goto fail;
1087         if (ring_stats->enq_quota_objs != last_quota_items + num_items)
1088                 goto fail;
1089
1090         last_quota_ops   = ring_stats->enq_quota_bulk;
1091         last_quota_items = ring_stats->enq_quota_objs;
1092
1093
1094         printf("Test stats for MP burst enqueue above watermark.\n");
1095         num_items = 2;
1096         ret = rte_ring_mp_enqueue_burst(r, cur_src, num_items);
1097         if ((ret & RTE_RING_SZ_MASK) != num_items)
1098                 goto fail;
1099
1100         /* Watermark stats should have changed. */
1101         if (ring_stats->enq_quota_bulk != last_quota_ops +1)
1102                 goto fail;
1103         if (ring_stats->enq_quota_objs != last_quota_items + num_items)
1104                 goto fail;
1105
1106         last_quota_ops   = ring_stats->enq_quota_bulk;
1107         last_quota_items = ring_stats->enq_quota_objs;
1108
1109
1110         printf("Test stats for SP bulk enqueue above watermark.\n");
1111         num_items = 4;
1112         ret = rte_ring_sp_enqueue_bulk(r, cur_src, num_items);
1113         if (ret != -EDQUOT)
1114                 goto fail;
1115
1116         /* Watermark stats should have changed. */
1117         if (ring_stats->enq_quota_bulk != last_quota_ops +1)
1118                 goto fail;
1119         if (ring_stats->enq_quota_objs != last_quota_items + num_items)
1120                 goto fail;
1121
1122         last_quota_ops   = ring_stats->enq_quota_bulk;
1123         last_quota_items = ring_stats->enq_quota_objs;
1124
1125
1126         printf("Test stats for MP bulk enqueue above watermark.\n");
1127         num_items = 8;
1128         ret = rte_ring_mp_enqueue_bulk(r, cur_src, num_items);
1129         if (ret != -EDQUOT)
1130                 goto fail;
1131
1132         /* Watermark stats should have changed. */
1133         if (ring_stats->enq_quota_bulk != last_quota_ops +1)
1134                 goto fail;
1135         if (ring_stats->enq_quota_objs != last_quota_items + num_items)
1136                 goto fail;
1137
1138         printf("Test watermark success stats.\n");
1139         /* Success stats should be same as last non-watermarked enqueue. */
1140         if (ring_stats->enq_success_bulk != last_enqueue_ops)
1141                 goto fail;
1142         if (ring_stats->enq_success_objs != last_enqueue_items)
1143                 goto fail;
1144
1145
1146         /* Cleanup. */
1147
1148         /* Empty the ring. */
1149         for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
1150                 rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
1151                 cur_dst += MAX_BULK;
1152         }
1153
1154         /* Reset the watermark. */
1155         rte_ring_set_water_mark(r, 0);
1156
1157         /* Reset the ring stats. */
1158         memset(&r->stats[lcore_id], 0, sizeof(r->stats[lcore_id]));
1159
1160         /* Free memory before test completed */
1161         free(src);
1162         free(dst);
1163         return 0;
1164
1165 fail:
1166         free(src);
1167         free(dst);
1168         return -1;
1169 #endif
1170 }
1171
1172 /*
1173  * it will always fail to create ring with a wrong ring size number in this function
1174  */
1175 static int
1176 test_ring_creation_with_wrong_size(void)
1177 {
1178         struct rte_ring * rp = NULL;
1179
1180         /* Test if ring size is not power of 2 */
1181         rp = rte_ring_create("test_bad_ring_size", RING_SIZE + 1, SOCKET_ID_ANY, 0);
1182         if (NULL != rp) {
1183                 return -1;
1184         }
1185
1186         /* Test if ring size is exceeding the limit */
1187         rp = rte_ring_create("test_bad_ring_size", (RTE_RING_SZ_MASK + 1), SOCKET_ID_ANY, 0);
1188         if (NULL != rp) {
1189                 return -1;
1190         }
1191         return 0;
1192 }
1193
1194 /*
1195  * it tests if it would always fail to create ring with an used ring name
1196  */
1197 static int
1198 test_ring_creation_with_an_used_name(void)
1199 {
1200         struct rte_ring * rp;
1201
1202         rp = rte_ring_create("test", RING_SIZE, SOCKET_ID_ANY, 0);
1203         if (NULL != rp)
1204                 return -1;
1205
1206         return 0;
1207 }
1208
1209 /*
1210  * Test to if a non-power of 2 count causes the create
1211  * function to fail correctly
1212  */
1213 static int
1214 test_create_count_odd(void)
1215 {
1216         struct rte_ring *r = rte_ring_create("test_ring_count",
1217                         4097, SOCKET_ID_ANY, 0 );
1218         if(r != NULL){
1219                 return -1;
1220         }
1221         return 0;
1222 }
1223
1224 static int
1225 test_lookup_null(void)
1226 {
1227         struct rte_ring *rlp = rte_ring_lookup("ring_not_found");
1228         if (rlp ==NULL)
1229         if (rte_errno != ENOENT){
1230                 printf( "test failed to returnn error on null pointer\n");
1231                 return -1;
1232         }
1233         return 0;
1234 }
1235
1236 /*
1237  * it tests some more basic ring operations
1238  */
1239 static int
1240 test_ring_basic_ex(void)
1241 {
1242         int ret = -1;
1243         unsigned i;
1244         struct rte_ring * rp;
1245         void **obj = NULL;
1246
1247         obj = rte_calloc("test_ring_basic_ex_malloc", RING_SIZE, sizeof(void *), 0);
1248         if (obj == NULL) {
1249                 printf("test_ring_basic_ex fail to rte_malloc\n");
1250                 goto fail_test;
1251         }
1252
1253         rp = rte_ring_create("test_ring_basic_ex", RING_SIZE, SOCKET_ID_ANY,
1254                         RING_F_SP_ENQ | RING_F_SC_DEQ);
1255         if (rp == NULL) {
1256                 printf("test_ring_basic_ex fail to create ring\n");
1257                 goto fail_test;
1258         }
1259
1260         if (rte_ring_lookup("test_ring_basic_ex") != rp) {
1261                 goto fail_test;
1262         }
1263
1264         if (rte_ring_empty(rp) != 1) {
1265                 printf("test_ring_basic_ex ring is not empty but it should be\n");
1266                 goto fail_test;
1267         }
1268
1269         printf("%u ring entries are now free\n", rte_ring_free_count(rp));
1270
1271         for (i = 0; i < RING_SIZE; i ++) {
1272                 rte_ring_enqueue(rp, obj[i]);
1273         }
1274
1275         if (rte_ring_full(rp) != 1) {
1276                 printf("test_ring_basic_ex ring is not full but it should be\n");
1277                 goto fail_test;
1278         }
1279
1280         for (i = 0; i < RING_SIZE; i ++) {
1281                 rte_ring_dequeue(rp, &obj[i]);
1282         }
1283
1284         if (rte_ring_empty(rp) != 1) {
1285                 printf("test_ring_basic_ex ring is not empty but it should be\n");
1286                 goto fail_test;
1287         }
1288
1289         /* Covering the ring burst operation */
1290         ret = rte_ring_enqueue_burst(rp, obj, 2);
1291         if ((ret & RTE_RING_SZ_MASK) != 2) {
1292                 printf("test_ring_basic_ex: rte_ring_enqueue_burst fails \n");
1293                 goto fail_test;
1294         }
1295
1296         ret = rte_ring_dequeue_burst(rp, obj, 2);
1297         if (ret != 2) {
1298                 printf("test_ring_basic_ex: rte_ring_dequeue_burst fails \n");
1299                 goto fail_test;
1300         }
1301
1302         ret = 0;
1303 fail_test:
1304         if (obj != NULL)
1305                 rte_free(obj);
1306
1307         return ret;
1308 }
1309
1310 static int
1311 test_ring(void)
1312 {
1313         /* some more basic operations */
1314         if (test_ring_basic_ex() < 0)
1315                 return -1;
1316
1317         rte_atomic32_init(&synchro);
1318
1319         if (r == NULL)
1320                 r = rte_ring_create("test", RING_SIZE, SOCKET_ID_ANY, 0);
1321         if (r == NULL)
1322                 return -1;
1323
1324         /* retrieve the ring from its name */
1325         if (rte_ring_lookup("test") != r) {
1326                 printf("Cannot lookup ring from its name\n");
1327                 return -1;
1328         }
1329
1330         /* burst operations */
1331         if (test_ring_burst_basic() < 0)
1332                 return -1;
1333
1334         /* basic operations */
1335         if (test_ring_basic() < 0)
1336                 return -1;
1337
1338         /* ring stats */
1339         if (test_ring_stats() < 0)
1340                 return -1;
1341
1342         /* basic operations */
1343         if (test_live_watermark_change() < 0)
1344                 return -1;
1345
1346         if ( test_set_watermark() < 0){
1347                 printf ("Test failed to detect invalid parameter\n");
1348                 return -1;
1349         }
1350         else
1351                 printf ( "Test detected forced bad watermark values\n");
1352
1353         if ( test_create_count_odd() < 0){
1354                         printf ("Test failed to detect odd count\n");
1355                         return -1;
1356                 }
1357                 else
1358                         printf ( "Test detected odd count\n");
1359
1360         if ( test_lookup_null() < 0){
1361                                 printf ("Test failed to detect NULL ring lookup\n");
1362                                 return -1;
1363                         }
1364                         else
1365                                 printf ( "Test detected NULL ring lookup \n");
1366
1367         /* test of creating ring with wrong size */
1368         if (test_ring_creation_with_wrong_size() < 0)
1369                 return -1;
1370
1371         /* test of creation ring with an used name */
1372         if (test_ring_creation_with_an_used_name() < 0)
1373                 return -1;
1374
1375         /* dump the ring status */
1376         rte_ring_list_dump(stdout);
1377
1378         return 0;
1379 }
1380
1381 REGISTER_TEST_COMMAND(ring_autotest, test_ring);