]> git.proxmox.com Git - ceph.git/blame - ceph/src/dpdk/app/test/test_ring.c
projects / ceph.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bump version to 12.2.12-pve1
[ceph.git] / ceph / src / dpdk / app / test / test_ring.c
CommitLineData
7c673cae
FG		 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
104static rte_atomic32_t synchro;
105
106static 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
118static int
119check_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
182static int
183test_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 */
206static int
207test_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
231error:
232 return -1;
233}
234
235/*
236 * helper routine for test_ring_basic
237 */
238static int
239test_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
278static int
279test_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
482static int
483test_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
766static int
767test_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
1165fail:
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 */
1175static int
1176test_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 */
1197static int
1198test_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 */
1213static int
1214test_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
1224static int
1225test_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 */
1239static int
1240test_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;
1303fail_test:
1304 if (obj != NULL)
1305 rte_free(obj);
1306
1307 return ret;
1308}
1309
1310static int
1311test_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
1381REGISTER_TEST_COMMAND(ring_autotest, test_ring);
Ceph