git.droids-corp.org / dpdk.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
app/testpmd: enable DDP remove profile feature
[dpdk.git] / test / test / test_ring.c
diff --git a/test/test/test_ring.c b/test/test/test_ring.c
index 666a451..858ebc1 100644 (file)
--- a/test/test/test_ring.c
+++ b/test/test/test_ring.c
@@ -117,20 +117,21 @@ test_ring_basic_full_empty(void * const src[], void *dst[])
                rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
                printf("%s: iteration %u, random shift: %u;\n",
                    __func__, i, rand);
-               TEST_RING_VERIFY(-ENOBUFS != rte_ring_enqueue_bulk(r, src,
-                   rand));
-               TEST_RING_VERIFY(0 == rte_ring_dequeue_bulk(r, dst, rand));
+               TEST_RING_VERIFY(rte_ring_enqueue_bulk(r, src, rand,
+                               NULL) != 0);
+               TEST_RING_VERIFY(rte_ring_dequeue_bulk(r, dst, rand,
+                               NULL) == rand);
 
                /* fill the ring */
-               TEST_RING_VERIFY(-ENOBUFS != rte_ring_enqueue_bulk(r, src,
-                   rsz));
+               TEST_RING_VERIFY(rte_ring_enqueue_bulk(r, src, rsz, NULL) != 0);
                TEST_RING_VERIFY(0 == rte_ring_free_count(r));
                TEST_RING_VERIFY(rsz == rte_ring_count(r));
                TEST_RING_VERIFY(rte_ring_full(r));
                TEST_RING_VERIFY(0 == rte_ring_empty(r));
 
                /* empty the ring */
-               TEST_RING_VERIFY(0 == rte_ring_dequeue_bulk(r, dst, rsz));
+               TEST_RING_VERIFY(rte_ring_dequeue_bulk(r, dst, rsz,
+                               NULL) == rsz);
                TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
                TEST_RING_VERIFY(0 == rte_ring_count(r));
                TEST_RING_VERIFY(0 == rte_ring_full(r));
@@ -169,39 +170,39 @@ test_ring_basic(void)
        cur_dst = dst;
 
        printf("enqueue 1 obj\n");
-       ret = rte_ring_sp_enqueue_bulk(r, cur_src, 1);
+       ret = rte_ring_sp_enqueue_bulk(r, cur_src, 1, NULL);
        cur_src += 1;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("enqueue 2 objs\n");
-       ret = rte_ring_sp_enqueue_bulk(r, cur_src, 2);
+       ret = rte_ring_sp_enqueue_bulk(r, cur_src, 2, NULL);
        cur_src += 2;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("enqueue MAX_BULK objs\n");
-       ret = rte_ring_sp_enqueue_bulk(r, cur_src, MAX_BULK);
+       ret = rte_ring_sp_enqueue_bulk(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue 1 obj\n");
-       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 1);
+       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 1, NULL);
        cur_dst += 1;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue 2 objs\n");
-       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 2);
+       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, 2, NULL);
        cur_dst += 2;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue MAX_BULK objs\n");
-       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, MAX_BULK);
+       ret = rte_ring_sc_dequeue_bulk(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        /* check data */
@@ -215,39 +216,39 @@ test_ring_basic(void)
        cur_dst = dst;
 
        printf("enqueue 1 obj\n");
-       ret = rte_ring_mp_enqueue_bulk(r, cur_src, 1);
+       ret = rte_ring_mp_enqueue_bulk(r, cur_src, 1, NULL);
        cur_src += 1;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("enqueue 2 objs\n");
-       ret = rte_ring_mp_enqueue_bulk(r, cur_src, 2);
+       ret = rte_ring_mp_enqueue_bulk(r, cur_src, 2, NULL);
        cur_src += 2;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("enqueue MAX_BULK objs\n");
-       ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
+       ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue 1 obj\n");
-       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 1);
+       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 1, NULL);
        cur_dst += 1;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue 2 objs\n");
-       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 2);
+       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, 2, NULL);
        cur_dst += 2;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        printf("dequeue MAX_BULK objs\n");
-       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
+       ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK;
-       if (ret != 0)
+       if (ret == 0)
                goto fail;
 
        /* check data */
@@ -262,13 +263,13 @@ test_ring_basic(void)
 
        printf("fill and empty the ring\n");
        for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
-               ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK);
+               ret = rte_ring_mp_enqueue_bulk(r, cur_src, MAX_BULK, NULL);
                cur_src += MAX_BULK;
-               if (ret != 0)
+               if (ret == 0)
                        goto fail;
-               ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK);
+               ret = rte_ring_mc_dequeue_bulk(r, cur_dst, MAX_BULK, NULL);
                cur_dst += MAX_BULK;
-               if (ret != 0)
+               if (ret == 0)
                        goto fail;
        }
 
@@ -292,27 +293,27 @@ test_ring_basic(void)
        cur_src = src;
        cur_dst = dst;
 
-       ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
+       ret = rte_ring_enqueue_bulk(r, cur_src, num_elems, NULL);
        cur_src += num_elems;
-       if (ret != 0) {
+       if (ret == 0) {
                printf("Cannot enqueue\n");
                goto fail;
        }
-       ret = rte_ring_enqueue_bulk(r, cur_src, num_elems);
+       ret = rte_ring_enqueue_bulk(r, cur_src, num_elems, NULL);
        cur_src += num_elems;
-       if (ret != 0) {
+       if (ret == 0) {
                printf("Cannot enqueue\n");
                goto fail;
        }
-       ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
+       ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems, NULL);
        cur_dst += num_elems;
-       if (ret != 0) {
+       if (ret == 0) {
                printf("Cannot dequeue\n");
                goto fail;
        }
-       ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems);
+       ret = rte_ring_dequeue_bulk(r, cur_dst, num_elems, NULL);
        cur_dst += num_elems;
-       if (ret != 0) {
+       if (ret == 0) {
                printf("Cannot dequeue2\n");
                goto fail;
        }
@@ -373,37 +374,37 @@ test_ring_burst_basic(void)
 
        printf("Test SP & SC basic functions \n");
        printf("enqueue 1 obj\n");
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, 1);
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, 1, NULL);
        cur_src += 1;
        if ((ret & RTE_RING_SZ_MASK) != 1)
                goto fail;
 
        printf("enqueue 2 objs\n");
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, 2, NULL);
        cur_src += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
        printf("enqueue MAX_BULK objs\n");
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK) ;
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                goto fail;
 
        printf("dequeue 1 obj\n");
-       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 1) ;
+       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 1, NULL);
        cur_dst += 1;
        if ((ret & RTE_RING_SZ_MASK) != 1)
                goto fail;
 
        printf("dequeue 2 objs\n");
-       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
+       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2, NULL);
        cur_dst += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
        printf("dequeue MAX_BULK objs\n");
-       ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
+       ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                goto fail;
@@ -421,7 +422,7 @@ test_ring_burst_basic(void)
 
        printf("Test enqueue without enough memory space \n");
        for (i = 0; i< (RING_SIZE/MAX_BULK - 1); i++) {
-               ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
+               ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
                cur_src += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK) {
                        goto fail;
@@ -429,14 +430,14 @@ test_ring_burst_basic(void)
        }
 
        printf("Enqueue 2 objects, free entries = MAX_BULK - 2  \n");
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, 2);
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, 2, NULL);
        cur_src += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
        printf("Enqueue the remaining entries = MAX_BULK - 2  \n");
        /* Always one free entry left */
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK - 3;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
                goto fail;
@@ -446,25 +447,25 @@ test_ring_burst_basic(void)
                goto fail;
 
        printf("Test enqueue for a full entry  \n");
-       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK);
+       ret = rte_ring_sp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
        if ((ret & RTE_RING_SZ_MASK) != 0)
                goto fail;
 
        printf("Test dequeue without enough objects \n");
        for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
-               ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
+               ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
                cur_dst += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                        goto fail;
        }
 
        /* Available memory space for the exact MAX_BULK entries */
-       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2);
+       ret = rte_ring_sc_dequeue_burst(r, cur_dst, 2, NULL);
        cur_dst += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
-       ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK);
+       ret = rte_ring_sc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK - 3;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
                goto fail;
@@ -488,37 +489,37 @@ test_ring_burst_basic(void)
        printf("Test MP & MC basic functions \n");
 
        printf("enqueue 1 obj\n");
-       ret = rte_ring_mp_enqueue_burst(r, cur_src, 1);
+       ret = rte_ring_mp_enqueue_burst(r, cur_src, 1, NULL);
        cur_src += 1;
        if ((ret & RTE_RING_SZ_MASK) != 1)
                goto fail;
 
        printf("enqueue 2 objs\n");
-       ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
+       ret = rte_ring_mp_enqueue_burst(r, cur_src, 2, NULL);
        cur_src += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
        printf("enqueue MAX_BULK objs\n");
-       ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
+       ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                goto fail;
 
        printf("dequeue 1 obj\n");
-       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 1);
+       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 1, NULL);
        cur_dst += 1;
        if ((ret & RTE_RING_SZ_MASK) != 1)
                goto fail;
 
        printf("dequeue 2 objs\n");
-       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
+       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2, NULL);
        cur_dst += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
        printf("dequeue MAX_BULK objs\n");
-       ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
+       ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                goto fail;
@@ -536,11 +537,11 @@ test_ring_burst_basic(void)
 
        printf("fill and empty the ring\n");
        for (i = 0; i<RING_SIZE/MAX_BULK; i++) {
-               ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
+               ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
                cur_src += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                        goto fail;
-               ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
+               ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
                cur_dst += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                        goto fail;
@@ -559,19 +560,19 @@ test_ring_burst_basic(void)
 
        printf("Test enqueue without enough memory space \n");
        for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
-               ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
+               ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
                cur_src += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                        goto fail;
        }
 
        /* Available memory space for the exact MAX_BULK objects */
-       ret = rte_ring_mp_enqueue_burst(r, cur_src, 2);
+       ret = rte_ring_mp_enqueue_burst(r, cur_src, 2, NULL);
        cur_src += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
-       ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK);
+       ret = rte_ring_mp_enqueue_burst(r, cur_src, MAX_BULK, NULL);
        cur_src += MAX_BULK - 3;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
                goto fail;
@@ -579,19 +580,19 @@ test_ring_burst_basic(void)
 
        printf("Test dequeue without enough objects \n");
        for (i = 0; i<RING_SIZE/MAX_BULK - 1; i++) {
-               ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
+               ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
                cur_dst += MAX_BULK;
                if ((ret & RTE_RING_SZ_MASK) != MAX_BULK)
                        goto fail;
        }
 
        /* Available objects - the exact MAX_BULK */
-       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2);
+       ret = rte_ring_mc_dequeue_burst(r, cur_dst, 2, NULL);
        cur_dst += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
-       ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK);
+       ret = rte_ring_mc_dequeue_burst(r, cur_dst, MAX_BULK, NULL);
        cur_dst += MAX_BULK - 3;
        if ((ret & RTE_RING_SZ_MASK) != MAX_BULK - 3)
                goto fail;
@@ -609,12 +610,12 @@ test_ring_burst_basic(void)
 
        printf("Covering rte_ring_enqueue_burst functions \n");
 
-       ret = rte_ring_enqueue_burst(r, cur_src, 2);
+       ret = rte_ring_enqueue_burst(r, cur_src, 2, NULL);
        cur_src += 2;
        if ((ret & RTE_RING_SZ_MASK) != 2)
                goto fail;
 
-       ret = rte_ring_dequeue_burst(r, cur_dst, 2);
+       ret = rte_ring_dequeue_burst(r, cur_dst, 2, NULL);
        cur_dst += 2;
        if (ret != 2)
                goto fail;
@@ -748,13 +749,13 @@ test_ring_basic_ex(void)
        }
 
        /* Covering the ring burst operation */
-       ret = rte_ring_enqueue_burst(rp, obj, 2);
+       ret = rte_ring_enqueue_burst(rp, obj, 2, NULL);
        if ((ret & RTE_RING_SZ_MASK) != 2) {
                printf("test_ring_basic_ex: rte_ring_enqueue_burst fails \n");
                goto fail_test;
        }
 
-       ret = rte_ring_dequeue_burst(rp, obj, 2);
+       ret = rte_ring_dequeue_burst(rp, obj, 2, NULL);
        if (ret != 2) {
                printf("test_ring_basic_ex: rte_ring_dequeue_burst fails \n");
                goto fail_test;
DPDK repo used for reviews