ring: eliminate duplication of size and mask fields
[dpdk.git] / 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->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->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->watermark != r->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);