Skip to contentSkip to conversation

wrong pointer passed of ring

PATCH In review Feifei Wang 4 participants 67 messages Jul 29, 2020 – Sep 23, 2020

lore
Share & tools
lore
#0 lore raw

cover wrong pointer passed of ring

Fix wrong pointer passed problems when using rte_ring_[sp|mp]enqueue APIs to enqueue one element into the ring.

Feifei Wang (2):
ring: fix the misdescription of the param test/ring: fix wrong parameter passed to the enqueue APIs

 app/test/test_ring.h       | 6 +++---
 lib/librte_ring/rte_ring.h | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)
Signature · 1 line
2.17.1
#1 lore raw

PATCH 1/2 ring: fix the misdescription of the param

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/librte_ring/rte_ring.h +3 -3
index da17ed6d7..418536b61 100644
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.
  * @return
  *   - 0: Success; objects enqueued.
  *   - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued.
@@ -293,7 +293,7 @@ rte_ring_mp_enqueue(struct rte_ring *r, void *obj)
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.
  * @return
  *   - 0: Success; objects enqueued.
  *   - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued.
@@ -314,7 +314,7 @@ rte_ring_sp_enqueue(struct rte_ring *r, void *obj)
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.
  * @return
  *   - 0: Success; objects enqueued.
  *   - -ENOBUFS: Not enough room in the ring to enqueue; no object is enqueued.
Signature · 1 line
2.17.1
#2 lore raw

Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

Quoted 3 lines · Feifei Wang

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

I understand void * as a pointer to an object you don't know the type of. I would keep the current description.

Honnappa, Konstantin, Olivier ?

Quoted 20 lines
Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/librte_ring/rte_ring.h +1 -1
index da17ed6d7..418536b61 100644
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.
Signature · 1 line
David Marchand
#3 lore raw

Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

Quoted 8 lines
Quoted 3 lines

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

I understand void * as a pointer to an object you don't know the type of. I would keep the current description.

Honnappa, Konstantin, Olivier ?

I think current one is a bit cleaner.
Konstantin

Quoted 25 lines
Quoted 16 lines
Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/librte_ring/rte_ring.h +0 -0
index da17ed6d7..418536b61 100644

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table, · line 279

Quoted 5 lines
lib/librte_ring/rte_ring.h +1 -1
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table,
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.

--
David Marchand

#4 lore raw

Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

<snip>

Quoted 7 lines

Subject: RE: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

Quoted 4 lines
Quoted 3 lines

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

Quoted 6 lines
Quoted 4 lines

I understand void * as a pointer to an object you don't know the type of. I would keep the current description.

Honnappa, Konstantin, Olivier ?

I think current one is a bit cleaner.

+1, the existing documentation is fine.

Quoted 29 lines

Konstantin

Quoted 11 lines
Quoted 11 lines
Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
Quoted 5 lines

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void *

Quoted 5 lines
lib/librte_ring/rte_ring.h +0 -0
index da17ed6d7..418536b61 100644
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void *

const *obj_table,

Quoted 9 lines

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table, · line 279

Quoted 5 lines
lib/librte_ring/rte_ring.h +1 -1
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.

--
David Marchand

#5 lore raw

[dpdk-dev] 回复: [PATCH v1 1/2] ring: fix the misdescription of the param

In reply to David Marchand

Hi, David, Konstantin and Honnappa

Quoted 10 lines

-----邮件原件-----
发件人: David Marchand <[email protected]>
发送时间: 2020年7月30日 0:00
收件人: Feifei Wang <[email protected]>; Ananyev, Konstantin <[email protected]>; Honnappa Nagarahalli <[email protected]>; Olivier Matz <[email protected]> 抄送: dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>; [email protected]
主题: Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

Quoted 9 lines
Quoted 3 lines · Feifei Wang

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

I understand void * as a pointer to an object you don't know the type of. I would keep the current description.

Sorry for my commit message cannot express my view clearly. Following is my supplementary explanation of this:

First, the APIs to be changed are:
1. rte_ring_mp_enqueue
2. rte_ring_sp_enqueue
3. rte_ring_enqueue

Second, Let's use an example to explain this:
1. We call API in form: rte_ring_enqueue(r, obj).
2. Current function header indicates that we will have ring[idx] = *obj.
3. However, this is not the case, what we eventually have is: ring[idx] = obj.

So I think the current function header is misleading or maybe the implementation of above three functions need to be changed.

Quoted 27 lines

Honnappa, Konstantin, Olivier ?

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void *

Quoted 15 lines
Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/librte_ring/rte_ring.h +0 -0
index da17ed6d7..418536b61 100644
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void *

const *obj_table,

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table, · line 279

Quoted 5 lines
lib/librte_ring/rte_ring.h +1 -1
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.

--
David Marchand

#6 lore raw

Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

<snip>

Quoted 15 lines
Quoted 12 lines

主题: Re: [dpdk-dev] [PATCH v1 1/2] ring: fix the misdescription of the param

Quoted 3 lines · Feifei Wang

When enqueue one element to the ring, the param "obj" should be the object to be added into the ring. The object is of type void*.

I understand void * as a pointer to an object you don't know the type of. I would keep the current description.

Sorry for my commit message cannot express my view clearly. Following is my supplementary explanation of this:

Quoted 8 lines

First, the APIs to be changed are:
1. rte_ring_mp_enqueue
2. rte_ring_sp_enqueue
3. rte_ring_enqueue

Second, Let's use an example to explain this:
1. We call API in form: rte_ring_enqueue(r, obj).
2. Current function header indicates that we will have ring[idx] = *obj.

When you say function header, I am assuming you are talking about the documentation. IMO, the current documentation does not convey any details of the implementation. It is talking about what is expected from the user.

Quoted 33 lines

3. However, this is not the case, what we eventually have is: ring[idx] = obj.

So I think the current function header is misleading or maybe the implementation of above three functions need to be changed.

Quoted 27 lines

Honnappa, Konstantin, Olivier ?

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void *

Quoted 15 lines
Fixes af75078fece3 ("first public release")
---
 lib/librte_ring/rte_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
lib/librte_ring/rte_ring.h +0 -0
index da17ed6d7..418536b61 100644
@@ -276,7 +276,7 @@ rte_ring_enqueue_bulk(struct rte_ring *r, void *

const *obj_table,

lib/librte_ring/rte_ring.h rte_ring_enqueue_bulk(struct rte_ring *r, void * const *obj_table, · line 279

Quoted 5 lines
lib/librte_ring/rte_ring.h +1 -1
  * @param r
  *   A pointer to the ring structure.
  * @param obj
- *   A pointer to the object to be added.
+ *   A pointer (object) to be added.

--
David Marchand

#7 lore raw

PATCH 2/2 test/ring: fix wrong param passed to the enqueue APIs

In reply to Feifei Wang

When enqueue one element (object of type void*) to ring in the performance test, a pointer (the object to be enqueued) should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers (objects).

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
#8 lore raw

Re: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Hello Feifei,

Quoted 5 lines · Feifei Wang

When enqueue one element (object of type void*) to ring in the performance test, a pointer (the object to be enqueued) should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers (objects).

Good catch.
Are we missing a check in the UT so that dequeued object is what had been enqueued?

Quoted 33 lines
Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -4
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
        if ((esize) == -1)
                switch (api_type) {
                case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_enqueue(r, obj);
+                       return rte_ring_enqueue(r, *obj);
                case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_sp_enqueue(r, obj);
+                       return rte_ring_sp_enqueue(r, *obj);
                case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_mp_enqueue(r, obj);
+                       return rte_ring_mp_enqueue(r, *obj);
                case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
                        return rte_ring_enqueue_bulk(r, obj, n, NULL);
                case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
--

2.17.1

Signature · 1 line
David Marchand
#9 lore raw

[dpdk-dev] 回复: [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Hi, David

Quoted 16 lines

-----邮件原件-----
发件人: David Marchand <[email protected]>
发送时间: 2020年7月29日 21:48
收件人: Feifei Wang <[email protected]>
抄送: Honnappa Nagarahalli <[email protected]>; Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>; dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>
主题: Re: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Hello Feifei,

Quoted 1 line · Feifei Wang
Quoted 6 lines
Quoted 4 lines

When enqueue one element (object of type void*) to ring in the performance test, a pointer (the object to be enqueued) should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers (objects).

Good catch.

Thanks very much.

Quoted 4 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer (object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer (object) that will be filled.

Quoted 39 lines

app/test/test_ring.h test_ring_enqueue(struct rte_ring *r, void **obj,

Quoted 17 lines
Fixes a9fe152363e2 ("test/ring: add custom element size functional

tests")
Cc: [email protected]
Cc: [email protected]

---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h index renamed from app/test/test_ring.h +0 -0

aa6ae67ca..d4b15af7c 100644

app/test/test_ring.h +0 -0
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj,

int esize, unsigned int n,

Quoted 15 lines
app/test/test_ring.h +3 -4
        if ((esize) == -1)
                switch (api_type) {
                case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_enqueue(r, obj);
+                       return rte_ring_enqueue(r, *obj);
                case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_sp_enqueue(r, obj);
+                       return rte_ring_sp_enqueue(r, *obj);
                case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-                       return rte_ring_mp_enqueue(r, obj);
+                       return rte_ring_mp_enqueue(r, *obj);
                case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
                        return rte_ring_enqueue_bulk(r, obj, n, NULL);
                case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
--
Quoted 2 lines

2.17.1

--
David Marchand

#10 lore raw

Re: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 9 lines · Feifei Wang
Quoted 4 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer (object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer (object) that will be filled.

That I get it.

What I meant is that the test enqueues an object in a ring until it is full [1], then dequeues all the ring [2].
1: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n814
2: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n825

If the test had checked that dequeued objects are the right one, we would have caught it.

But on the other hand, maybe another part of the functionnal ring tests already check this and we only need to fix this issue here.

Signature · 1 line
David Marchand
#11 lore raw

[dpdk-dev] 回复: [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 33 lines

-----邮件原件-----
发件人: David Marchand <[email protected]>
发送时间: 2020年7月29日 22:21
收件人: Feifei Wang <[email protected]>
抄送: Honnappa Nagarahalli <[email protected]>; Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>; dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>
主题: Re: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 10 lines · Feifei Wang
Quoted 4 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer (object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer (object) that will be filled.

That I get it.

What I meant is that the test enqueues an object in a ring until it is full [1], then dequeues all the ring [2].
1: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n814
2: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n825

Quoted 5 lines

If the test had checked that dequeued objects are the right one, we would have caught it.

But on the other hand, maybe another part of the functionnal ring tests already check this and we only need to fix this issue here.

Sorry I just misunderstood you.
1. Actually, for the APIs of test_ring.h, we lack a test to check whether the value of object enqueued into the ring matches that dequeued from the ring. But it is mainly used to measure the length of time from enqueue to dequeue. So I'm not sure it is necessary.
2. For the APIs of rte_ring.h, some tests can be used to test whether the value of object enqueued into the ring matches that dequeued from the ring. For example:
$table_autotest
$mbuf_autotest

Quoted 4 lines

--
David Marchand

--
Feifei

#12 lore raw

Re: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

<snip>

Quoted 5 lines
Quoted 5 lines
Quoted 2 lines · Feifei Wang
Quoted 2 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Yes, missing for single element enqueue/dequeue

Quoted 22 lines
Quoted 16 lines
Quoted 8 lines
Quoted 2 lines

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer (object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer (object) that will be filled.

That I get it.

What I meant is that the test enqueues an object in a ring until it is full [1], then dequeues all the ring [2].
1: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n814
2: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n825

Quoted 5 lines

If the test had checked that dequeued objects are the right one, we would have caught it.

But on the other hand, maybe another part of the functionnal ring tests already check this and we only need to fix this issue here.

Quoted 10 lines

Sorry I just misunderstood you.
1. Actually, for the APIs of test_ring.h, we lack a test to check whether the value of object enqueued into the ring matches that dequeued from the ring. But it is mainly used to measure the length of time from enqueue to dequeue. So I'm not sure it is necessary.
2. For the APIs of rte_ring.h, some tests can be used to test whether the value of object enqueued into the ring matches that dequeued from the ring. For example:
$table_autotest
$mbuf_autotest

The dequeued objects are checked against the enqueued objects for the bulk and burst APIs. Look at tests test_ring_burst_bulk_tests1..4. 'memcmp' is used to compare the enqueued objects against the dequeued ones. Similar comparison can be added in test_ring_basic_ex, test_ring_with_exact_size functions.

Quoted 8 lines
Quoted 4 lines

--
David Marchand

--
Feifei

#13 lore raw

[dpdk-dev] 回复: [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 55 lines

-----邮件原件-----
发件人: Honnappa Nagarahalli <[email protected]>
发送时间: 2020年7月30日 5:24
收件人: Feifei Wang <[email protected]>; David Marchand <[email protected]>
抄送: Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>; dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd <[email protected]> 主题: RE: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

<snip>

Quoted 5 lines
Quoted 5 lines
Quoted 2 lines · Feifei Wang
Quoted 2 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Yes, missing for single element enqueue/dequeue

Quoted 19 lines
Quoted 19 lines
Quoted 8 lines
Quoted 2 lines

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer (object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer (object) that will be filled.

That I get it.

What I meant is that the test enqueues an object in a ring until it is full [1], then dequeues all the ring [2].
1: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n814
2: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n825

If the test had checked that dequeued objects are the right one, we would have caught it.

Quoted 6 lines
Quoted 2 lines

But on the other hand, maybe another part of the functionnal ring tests already check this and we only need to fix this issue here.

Sorry I just misunderstood you.
1. Actually, for the APIs of test_ring.h, we lack a test to check whether the value of object enqueued into the ring matches that dequeued

from the ring.

Quoted 1 line

But it is mainly used to measure the length of time from enqueue to

dequeue.

Quoted 3 lines

So I'm not sure it is necessary.
2. For the APIs of rte_ring.h, some tests can be used to test whether the value of object enqueued into the ring matches that dequeued from the

ring.

Quoted 8 lines
Quoted 3 lines

For example:
$table_autotest
$mbuf_autotest

The dequeued objects are checked against the enqueued objects for the bulk and burst APIs. Look at tests test_ring_burst_bulk_tests1..4. 'memcmp' is used to compare the enqueued objects against the dequeued ones. Similar comparison can be added in test_ring_basic_ex, test_ring_with_exact_size functions.

Thank you for bringing that up.

Quoted 9 lines
Quoted 9 lines
Quoted 5 lines

--
David Marchand

--
Feifei

#14 lore raw

[dpdk-dev] 回复: [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 77 lines

-----邮件原件-----
发件人: Feifei Wang
发送时间: 2020年7月30日 18:29
收件人: Honnappa Nagarahalli <[email protected]>; David Marchand <[email protected]>
抄送: Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>; dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>; nd <[email protected]>; nd <[email protected]>
主题: 回复: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

Quoted 9 lines

-----邮件原件-----
发件人: Honnappa Nagarahalli <[email protected]> 发送时间: 2020年7月30日 5:24
收件人: Feifei Wang <[email protected]>; David Marchand <[email protected]>
抄送: Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>; dev <[email protected]>; nd <[email protected]>; dpdk stable <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd

<[email protected]>

Quoted 51 lines

主题: RE: [dpdk-dev] [PATCH v1 2/2] test/ring: fix wrong param passed to the enqueue APIs

<snip>

Quoted 5 lines
Quoted 5 lines
Quoted 2 lines · Feifei Wang
Quoted 2 lines

Are we missing a check in the UT so that dequeued object is what had been enqueued?

Yes, missing for single element enqueue/dequeue

Quoted 21 lines
Quoted 21 lines
Quoted 10 lines
Quoted 2 lines

Dequeue is not necessary to change because the param defined in rte_ring_dequeue is different from that in rte_ring_enqueue:
rte_ring_enqueue(struct rte_ring *r, void *obj): obj is a pointer
(object) to be added in the ring rte_ring_dequeue(struct rte_ring *r, void **obj_p): obj_p is a pointer to a void * pointer
(object) that will be filled.

That I get it.

What I meant is that the test enqueues an object in a ring until it is full [1], then dequeues all the ring [2].
1: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n814
2: https://git.dpdk.org/dpdk/tree/app/test/test_ring.c#n825

If the test had checked that dequeued objects are the right one, we would have caught it.

Quoted 7 lines
Quoted 2 lines

But on the other hand, maybe another part of the functionnal ring tests already check this and we only need to fix this issue here.

Sorry I just misunderstood you.
1. Actually, for the APIs of test_ring.h, we lack a test to check whether the value of object enqueued into the ring matches that dequeued

from the ring.

Quoted 1 line

But it is mainly used to measure the length of time from enqueue to

dequeue.

Quoted 4 lines

So I'm not sure it is necessary.
2. For the APIs of rte_ring.h, some tests can be used to test whether the value of object enqueued into the ring matches that dequeued from the

ring.

Quoted 3 lines

For example:
$table_autotest
$mbuf_autotest

Quoted 7 lines
Quoted 3 lines

The dequeued objects are checked against the enqueued objects for the bulk and burst APIs. Look at tests test_ring_burst_bulk_tests1..4. 'memcmp' is used to compare the enqueued objects against the dequeued

ones.

Quoted 2 lines

Similar comparison can be added in test_ring_basic_ex, test_ring_with_exact_size functions.

Thank you for bringing that up.

Next, I will adding the test to check the value of dequeue against enqueue in test_ring_basic_ex, test_ring_with_exact_size functions. Furthermore, I will pack it and the current patch together and upload the new version to the community.

Quoted 9 lines
Quoted 9 lines
Quoted 9 lines
Quoted 5 lines

--
David Marchand

--
Feifei

#15 lore raw

v2 cover wrong pointer passed and add check

In reply to Feifei Wang

Fix wrong pointer passed problems when using test_ring_enqueue APIs to enqueue one element into the ring.

Furthermore, add check to validate the dequeued objects in test_ring.c when calling test_ring_enqueue APIs.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

Feifei Wang (4):
test/ring: fix wrong parameter passed to the enqueue APIs test/ring: fix wrong size used in memcmp test/ring: fix the wrong number of enq/deq elements test/ring: add check to validate the dequeued objects

 app/test/test_ring.c | 180 +++++++++++++++++++++++++++++++------------
 app/test/test_ring.h |   6 +-
 2 files changed, 135 insertions(+), 51 deletions(-)
Signature · 1 line
2.17.1
#16 lore raw

PATCH v2 1/4 test/ring: fix wrong parameter passed to the enqueue APIs

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
#17 lore raw

PATCH v2 2/4 test/ring: fix wrong size used in memcmp

In reply to Feifei Wang

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)
app/test/test_ring.c +21 -10
index 0ae97d341..c508a13a9 100644
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -538,9 +543,11 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
Signature · 1 line
2.17.1
#18 lore raw

Re: [dpdk-dev] [PATCH v2 2/4] test/ring: fix wrong size used in memcmp

<snip>

Quoted 19 lines

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

0ae97d341..c508a13a9 100644

app/test/test_ring.c test_ring_burst_bulk_tests1(unsigned int test_idx) · line 452

Quoted 10 lines
app/test/test_ring.c +6 -1
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);

Can you implement a function similar to 'test_ring_mem_init' to do this comparison?

Quoted 5 lines
app/test/test_ring.c +0 -0
 		}
 
 		/* Free memory before test completed */ @@ -538,9 +543,11

@@ test_ring_burst_bulk_tests2(unsigned int test_idx)

app/test/test_ring.c +0 -0
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);

app/test/test_ring.c test_ring_burst_bulk_tests2(unsigned int test_idx) · line 550

Quoted 10 lines
app/test/test_ring.c +5 -3
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));

I do not think, this change and the rest below are bug fixes. Can you please separate them into another commit?

Quoted 35 lines
app/test/test_ring.c +10 -7
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
--

2.17.1

#19 lore raw

[dpdk-dev] 回复: [PATCH v2 2/4] test/ring: fix wrong size used in memcmp

Quoted 37 lines

-----邮件原件-----
发件人: Honnappa Nagarahalli <[email protected]> 发送时间: 2020年8月27日 4:52
收件人: Feifei Wang <[email protected]>; Konstantin Ananyev <[email protected]>; Gavin Hu <[email protected]>; Olivier Matz <[email protected]>
抄送: [email protected]; nd <[email protected]>; Feifei Wang <[email protected]>; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
主题: RE: [PATCH v2 2/4] test/ring: fix wrong size used in memcmp

<snip>

Quoted 22 lines

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional

tests")
Cc: [email protected]
Cc: [email protected]

---
 app/test/test_ring.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

0ae97d341..c508a13a9 100644

app/test/test_ring.c +0 -0
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
Quoted 10 lines

app/test/test_ring.c test_ring_burst_bulk_tests1(unsigned int test_idx) · line 452

Quoted 8 lines
app/test/test_ring.c +6 -1
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);

Can you implement a function similar to 'test_ring_mem_init' to do this comparison?

Ok, the new function named 'test_ring_mem_cmp' will be added.

Quoted 8 lines

app/test/test_ring.c test_ring_burst_bulk_tests1(unsigned int test_idx) · line 455

Quoted 4 lines
app/test/test_ring.c +0 -0
 		}
 
 		/* Free memory before test completed */ @@ -538,9 +543,11

@@

Quoted 3 lines

test_ring_burst_bulk_tests2(unsigned int test_idx)
cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);

Quoted 11 lines

app/test/test_ring.c test_ring_burst_bulk_tests2(unsigned int test_idx) · line 550

Quoted 9 lines
app/test/test_ring.c +5 -3
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));

I do not think, this change and the rest below are bug fixes. Can you please separate them into another commit?

Actually, in the original code, 'memcmp' wants to check all bytes and ' rte_hexdump ' wants to print all bytes. However, 'cur_dst - dst' and 'cur_src - src' is the number of all elements rather the bytes of all elements. As a result, we need to correct it and make them check all bytes of the ring.

Quoted 36 lines
Quoted 36 lines
app/test/test_ring.c +10 -7
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
--

2.17.1

#20 lore raw

PATCH v2 3/4 test/ring: fix the wrong number of enq/deq elements

In reply to Feifei Wang

The actual capacity of ring should be the (RING_SIZE - 1), thus only (RING_SIZE - 1) elements can be enqueued into the ring.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c +2 -2
index c508a13a9..51bae0d48 100644
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_enqueue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
@@ -833,7 +833,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_dequeue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
Signature · 1 line
2.17.1
#21 lore raw

Re: [dpdk-dev] [PATCH v2 3/4] test/ring: fix the wrong number of enq/deq elements

<snip>

Quoted 6 lines

Subject: [PATCH v2 3/4] test/ring: fix the wrong number of enq/deq elements

The actual capacity of ring should be the (RING_SIZE - 1), thus only (RING_SIZE
- 1) elements can be enqueued into the ring.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")

This issue is not because of this commit. It is coming from af75078fece3.

Quoted 14 lines
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

c508a13a9..51bae0d48 100644

app/test/test_ring.c test_ring_basic_ex(void) · line 828

Quoted 8 lines
app/test/test_ring.c +1 -1
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_enqueue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);

Can you validate the return value of this function (which should have caught the error)?

app/test/test_ring.c test_ring_basic_ex(void) · line 839

Quoted 10 lines
app/test/test_ring.c +1 -1
 		}
@@ -833,7 +833,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_dequeue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);

Same here.

Quoted 3 lines

}
--
2.17.1

#22 lore raw

[dpdk-dev] 回复: [PATCH v2 3/4] test/ring: fix the wrong number of enq/deq elements

Quoted 15 lines

-----邮件原件-----
发件人: Honnappa Nagarahalli <[email protected]>
发送时间: 2020年8月27日 4:51
收件人: Feifei Wang <[email protected]>; Konstantin Ananyev <[email protected]>; Olivier Matz <[email protected]>; Gavin Hu <[email protected]>
抄送: [email protected]; nd <[email protected]>; Feifei Wang <[email protected]>; [email protected]; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
主题: RE: [PATCH v2 3/4] test/ring: fix the wrong number of enq/deq elements

<snip>

Quoted 8 lines
Quoted 3 lines

Subject: [PATCH v2 3/4] test/ring: fix the wrong number of enq/deq elements

The actual capacity of ring should be the (RING_SIZE - 1), thus only

(RING_SIZE

Quoted 3 lines

- 1) elements can be enqueued into the ring.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")

This issue is not because of this commit. It is coming from af75078fece3.

Sorry for my mistake, I will correct it.

Quoted 18 lines
Quoted 18 lines
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

c508a13a9..51bae0d48 100644

app/test/test_ring.c +0 -0
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
Quoted 7 lines

app/test/test_ring.c test_ring_basic_ex(void)

Quoted 5 lines
app/test/test_ring.c +1 -1
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_enqueue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);

Can you validate the return value of this function (which should have caught the error)?

Ok, only for these two loops, I will add test to validate the number of enqueue/dequeue elements.

Quoted 16 lines

app/test/test_ring.c test_ring_basic_ex(void) · line 839

Quoted 11 lines
app/test/test_ring.c +1 -1
 		}
@@ -833,7 +833,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_dequeue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);

Same here.

Quoted 3 lines

}
--
2.17.1

#23 lore raw

PATCH v2 4/4 test/ring: add check to validate the dequeued objects

In reply to Feifei Wang

For the single element enqueue and dequeue in test_ring_basic_ex and test_ring_with_exact_size, add check to validate the dequeued objects.

---
 app/test/test_ring.c | 145 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 109 insertions(+), 36 deletions(-)
app/test/test_ring.c +109 -36
index 51bae0d48..a1ff73a05 100644
@@ -791,15 +791,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -808,6 +802,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -823,8 +834,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
 		if (rte_ring_full(rp) != 1) {
@@ -834,8 +846,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
 		if (rte_ring_empty(rp) != 1) {
@@ -844,52 +857,88 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_src, src))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset dst */
+		if (esize[i] == -1)
+			memset(dst, 0, RING_SIZE * sizeof(void *));
+		else
+			memset(dst, 0, RING_SIZE * esize[i]);
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
 
@@ -900,8 +949,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -911,14 +960,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -936,6 +977,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = ((void **)src_orig) + 1;
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = ((void **)dst_orig) + 1;
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -952,33 +1009,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of elements\n",
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
@@ -987,10 +1047,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -998,7 +1070,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
Signature · 1 line
2.17.1
#24 lore raw

Re: [dpdk-dev] [PATCH v2 4/4] test/ring: add check to validate the dequeued objects

Hi Feifei,
Can you add this at the head of the series? It will help with proving that the test case fails and hence we need subsequent fixes.

Quoted 100 lines

-----Original Message-----
From: Feifei Wang <[email protected]>
Sent: Wednesday, August 5, 2020 1:14 AM
To: Honnappa Nagarahalli <[email protected]>; Konstantin Ananyev <[email protected]>
Cc: [email protected]; nd <[email protected]>; Feifei Wang <[email protected]>
Subject: [PATCH v2 4/4] test/ring: add check to validate the dequeued objects

For the single element enqueue and dequeue in test_ring_basic_ex and test_ring_with_exact_size, add check to validate the dequeued objects.

---
 app/test/test_ring.c | 145 ++++++++++++++++++++++++++++++++-----------
 1 file changed, 109 insertions(+), 36 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

51bae0d48..a1ff73a05 100644

app/test/test_ring.c +20 -8
@@ -791,15 +791,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -808,6 +802,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -823,8 +834,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
app/test/test_ring.c +2 -1
 		if (rte_ring_full(rp) != 1) {
@@ -834,8 +846,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
app/test/test_ring.c +9 -0
 		if (rte_ring_empty(rp) != 1) {
@@ -844,52 +857,88 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_src, src))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}

app/test/test_ring.c test_ring_basic_ex(void) · line 878

Quoted 10 lines
app/test/test_ring.c +7 -0
+
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset dst */
+		if (esize[i] == -1)
+			memset(dst, 0, RING_SIZE * sizeof(void *));
+		else
+			memset(dst, 0, RING_SIZE * esize[i]);

Can you convert the above into a function like 'test_ring_mem_reset'?

Quoted 107 lines
app/test/test_ring.c +31 -19
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
@@ -900,8 +949,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -911,14 +960,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -936,6 +977,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;

app/test/test_ring.c test_ring_with_exact_size(void) · line 987

Quoted 10 lines
app/test/test_ring.c +8 -0
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = ((void **)src_orig) + 1;

^^^^^^ This does not create an unaligned address. You have to use the typecasting to 'char *' like in the original code.

app/test/test_ring.c test_ring_with_exact_size(void) · line 993

Quoted 6 lines
app/test/test_ring.c +6 -0
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = ((void **)dst_orig) + 1;

Same here.

Quoted 91 lines
app/test/test_ring.c +8 -4
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -952,33 +1009,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of

elements */

app/test/test_ring.c +1 -1
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BURST);

app/test/test_ring.c +0 -0
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of

elements\n",

app/test/test_ring.c +18 -4
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) { @@ -987,10
+1047,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -998,7 +1070,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
--

2.17.1

#25 lore raw

[dpdk-dev] 回复: [PATCH v2 4/4] test/ring: add check to validate the dequeued objects

Hi, Honnappa

Quoted 10 lines

-----邮件原件-----
发件人: Honnappa Nagarahalli <[email protected]>
发送时间: 2020年8月27日 4:51
收件人: Feifei Wang <[email protected]>; Konstantin Ananyev <[email protected]>
抄送: [email protected]; nd <[email protected]>; Feifei Wang <[email protected]>; Honnappa Nagarahalli <[email protected]>; nd <[email protected]>
主题: RE: [PATCH v2 4/4] test/ring: add check to validate the dequeued objects

Quoted 3 lines

Hi Feifei,
Can you add this at the head of the series? It will help with proving that
the test case fails and hence we need subsequent fixes.

Ok, I will adjust it to the first one of the series.

Quoted 107 lines
Quoted 7 lines

-----Original Message-----
From: Feifei Wang <[email protected]>
Sent: Wednesday, August 5, 2020 1:14 AM
To: Honnappa Nagarahalli <[email protected]>; Konstantin Ananyev <[email protected]>
Cc: [email protected]; nd <[email protected]>; Feifei Wang

<[email protected]>

Quoted 99 lines

Subject: [PATCH v2 4/4] test/ring: add check to validate the dequeued objects

For the single element enqueue and dequeue in test_ring_basic_ex and test_ring_with_exact_size, add check to validate the dequeued objects.

---
 app/test/test_ring.c | 145
++++++++++++++++++++++++++++++++-----------
 1 file changed, 109 insertions(+), 36 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

51bae0d48..a1ff73a05 100644

app/test/test_ring.c +20 -8
@@ -791,15 +791,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -808,6 +802,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -823,8 +834,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
app/test/test_ring.c +2 -1
 		if (rte_ring_full(rp) != 1) {
@@ -834,8 +846,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
app/test/test_ring.c +11 -0
 		if (rte_ring_empty(rp) != 1) {
@@ -844,52 +857,88 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_src, src))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
+
 		/* Following tests use the configured flags to decide
Quoted 8 lines

app/test/test_ring.c test_ring_basic_ex(void) · line 878

Quoted 7 lines
app/test/test_ring.c +5 -0
 		 * SP/SC or MP/MC.
 		 */
+		/* reset dst */
+		if (esize[i] == -1)
+			memset(dst, 0, RING_SIZE * sizeof(void *));
+		else
+			memset(dst, 0, RING_SIZE * esize[i]);

Can you convert the above into a function like 'test_ring_mem_reset'?

Ok, the new function of "test_ring_mem_reset"(memset) and "test_ring_mem_cmp"(memcmp) will be added in the next version.

Quoted 110 lines
Quoted 110 lines
app/test/test_ring.c +31 -19
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
@@ -900,8 +949,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -911,14 +960,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -936,6 +977,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
Quoted 10 lines

app/test/test_ring.c test_ring_with_exact_size(void) · line 987

Quoted 8 lines
app/test/test_ring.c +8 -0
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = ((void **)src_orig) + 1;

^^^^^^ This does not create an unaligned address.
You have to use the typecasting to 'char *' like in the original code.

So, if I understand it correctly, the original code is to translate one byte. And for the new version, we also should translate one byte rather than the size of a pointer.

Quoted 100 lines

app/test/test_ring.c test_ring_with_exact_size(void) · line 993

Quoted 7 lines
app/test/test_ring.c +6 -0
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = ((void **)dst_orig) + 1;

Same here.

Quoted 29 lines
app/test/test_ring.c +6 -4
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -952,33 +1009,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,

app/test/test_ring.c test_ring_with_exact_size(void) · line 1037

Quoted 10 lines
app/test/test_ring.c +2 -0
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of

elements */

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 6 lines
app/test/test_ring.c +1 -1
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of

elements\n",

Quoted 44 lines
app/test/test_ring.c +18 -4
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) { @@ -987,10
+1047,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -998,7 +1070,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
--

2.17.1

#26 lore raw

v3 cover fix wrong passed pointer and add check

In reply to Feifei Wang

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

v3:
1. Adjust the 'check dequeued objects' patch from the last to the first in the series. (Honnappa)
2. Add the new function 'test_ring_mem_cmp to replace 'memset' and print information of enqueue/dequeue elements if validation fails. (Honnappa)
3. Add test to validate the whether the enqueue and dequeue operation is successful for each time. (Honnappa)
4. Expand the scope of application for the macro TEST_RING_VERIF, and replace all ring APIs check with this macro. (Honnappa)

Feifei Wang (6):
test/ring: add check to validate dequeued objects test/ring: fix wrong parameter passed to the enqueue APIs test/ring: validate the return value of enq/deq elements test/ring: fix wrong number of enq/deq elements test/ring: fix wrong size used in memcmp test/ring: improve the application of macro

 app/test/test_ring.c | 382 ++++++++++++++++++++++---------------------
 app/test/test_ring.h |   6 +-
 2 files changed, 198 insertions(+), 190 deletions(-)
Signature · 1 line
2.17.1
#27 lore raw

PATCH v3 1/6 test/ring: add check to validate dequeued objects

Add check in test_ring_basic_ex and test_ring_with_exact_size for single element enqueue and dequeue operations to validate the dequeued objects.

---
 app/test/test_ring.c | 135 +++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 36 deletions(-)
app/test/test_ring.c +99 -36
index 0ae97d341..6e48cc0b1 100644
@@ -780,15 +780,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -797,6 +791,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -812,8 +823,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
 		if (rte_ring_full(rp) != 1) {
@@ -823,8 +835,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
 		if (rte_ring_empty(rp) != 1) {
@@ -833,52 +846,80 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, cur_src - src)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset memory of dst */
+		memset(dst, 0, RTE_PTR_DIFF(cur_src, src));
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
 
@@ -889,8 +930,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -900,14 +941,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -925,6 +958,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = (void **)((uintptr_t)src_orig + 1);
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = (void **)((uintptr_t)dst_orig + 1);
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -941,33 +990,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of elements\n",
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
@@ -976,10 +1028,20 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -987,7 +1049,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
Signature · 1 line
2.17.1
Reviewed-by on v3 1/6
#28 lore raw

Re: [dpdk-dev] [PATCH v3 1/6] test/ring: add check to validate dequeued objects

<snip>

Quoted 8 lines

Add check in test_ring_basic_ex and test_ring_with_exact_size for single element enqueue and dequeue operations to validate the dequeued objects.

Looks good.

Quoted 300 lines
---
 app/test/test_ring.c | 135 +++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 36 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

0ae97d341..6e48cc0b1 100644

app/test/test_ring.c +20 -8
@@ -780,15 +780,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -797,6 +791,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -812,8 +823,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
app/test/test_ring.c +2 -1
 		if (rte_ring_full(rp) != 1) {
@@ -823,8 +835,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
app/test/test_ring.c +61 -23
 		if (rte_ring_empty(rp) != 1) {
@@ -833,52 +846,80 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, cur_src - src)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset memory of dst */
+		memset(dst, 0, RTE_PTR_DIFF(cur_src, src));
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
@@ -889,8 +930,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -900,14 +941,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -925,6 +958,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = (void **)((uintptr_t)src_orig + 1);
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = (void **)((uintptr_t)dst_orig + 1);
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -941,33 +990,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of

elements */

app/test/test_ring.c +1 -1
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BURST);

app/test/test_ring.c +0 -0
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of

elements\n",

app/test/test_ring.c +16 -4
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) { @@ -976,10
+1028,20 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -987,7 +1049,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
--

2.17.1

#29 lore raw

PATCH v3 2/6 test/ring: fix wrong parameter passed to the enqueue APIs

In reply to Feifei Wang

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
Reviewed-by on v3 2/6
#30 lore raw

Re: [dpdk-dev] [PATCH v3 2/6] test/ring: fix wrong parameter passed to the enqueue APIs

<snip>

Quoted 5 lines

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Quoted 7 lines
Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
Quoted 26 lines
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h index renamed from app/test/test_ring.h +0 -0

aa6ae67ca..d4b15af7c 100644

app/test/test_ring.h +3 -3
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int
 esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);

case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
--
2.17.1

#31 lore raw

PATCH v3 3/6 test/ring: validate the return value of enq/deq elements

In reply to Feifei Wang

Validate the return value of single element enqueue/dequeue operation in the test.

---
 app/test/test_ring.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)
app/test/test_ring.c +22 -4
index 6e48cc0b1..63d44d85e 100644
@@ -823,8 +823,13 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_enqueue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
@@ -835,8 +840,13 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, cur_dst, esize[i], 1,
+			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_dequeue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
@@ -990,10 +1000,18 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
+			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
Signature · 1 line
2.17.1
Reviewed-by on v3 3/6
#32 lore raw

Re: [dpdk-dev] [PATCH v3 3/6] test/ring: validate the return value of enq/deq elements

<snip>

Quoted 7 lines

Validate the return value of single element enqueue/dequeue operation in the test.

Quoted 67 lines
---
 app/test/test_ring.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

6e48cc0b1..63d44d85e 100644

app/test/test_ring.c +20 -4
@@ -823,8 +823,13 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_enqueue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
@@ -835,8 +840,13 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, cur_dst, esize[i], 1,
+			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_dequeue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
@@ -990,10 +1000,18 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n",
 __func__);
+				goto test_fail;
+			}
+			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n",

__func__);

app/test/test_ring.c +2 -1
+				goto test_fail;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
--

2.17.1

#33 lore raw

PATCH v3 4/6 test/ring: fix wrong number of enq/deq elements

In reply to Feifei Wang

The ring capacity is (RING_SIZE - 1), thus only (RING_SIZE - 1) number of elements can be enqueued into the ring.

Fixes af75078fece3 ("first public release")
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c +2 -2
index 63d44d85e..811adc523 100644
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 			if (ret != 0) {
@@ -839,7 +839,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 			if (ret != 0) {
Signature · 1 line
2.17.1
Reviewed-by on v3 4/6
#34 lore raw

Re: [dpdk-dev] [PATCH v3 4/6] test/ring: fix wrong number of enq/deq elements

<snip>

Quoted 10 lines

The ring capacity is (RING_SIZE - 1), thus only (RING_SIZE - 1) number of elements can be enqueued into the ring.

Fixes af75078fece3 ("first public release")

Looks good

Quoted 30 lines
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

63d44d85e..811adc523 100644

app/test/test_ring.c +1 -1
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);
app/test/test_ring.c +1 -1
 			if (ret != 0) {
@@ -839,7 +839,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |
 TEST_RING_ELEM_SINGLE);

if (ret != 0) {
--
2.17.1

#35 lore raw

PATCH v3 5/6 test/ring: fix wrong size used in memcmp

In reply to Feifei Wang

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Furthermore, do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 59 ++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 32 deletions(-)
app/test/test_ring.c +27 -32
index 811adc523..4a2bd39fc 100644
@@ -258,6 +258,21 @@ test_ring_mem_init(void *obj, unsigned int count, int esize)
 			((uint32_t *)obj)[i] = i;
 }
 
+static int
+test_ring_mem_cmp(void *src, void *dst, unsigned int size)
+{
+	int ret;
+
+	ret = memcmp(src, dst, size);
+	if (ret) {
+		rte_hexdump(stdout, "src", src, size);
+		rte_hexdump(stdout, "dst", dst, size);
+		printf("data after dequeue is not the same\n");
+	}
+
+	return ret;
+}
+
 static void
 test_ring_print_test_string(const char *istr, unsigned int api_type, int esize)
 {
@@ -383,7 +398,7 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 	struct rte_ring *r;
 	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	int ret;
-	unsigned int i, j;
+	unsigned int i, j, temp_sz;
 	int rand;
 	const unsigned int rsz = RING_SIZE - 1;
 
@@ -444,7 +459,11 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			temp_sz = rsz * sizeof(void *);
+			if (esize[i] != -1)
+				temp_sz = rsz * esize[i];
+			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+						temp_sz) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -538,12 +557,8 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -614,12 +629,8 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -747,12 +758,8 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -857,12 +864,8 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_src - src)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_src, src)))
 			goto fail_test;
-		}
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -909,12 +912,8 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -1047,12 +1046,8 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto test_fail;
-		}
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
Signature · 1 line
2.17.1
#36 lore raw

Re: [dpdk-dev] [PATCH v3 5/6] test/ring: fix wrong size used in memcmp

<snip>

Quoted 7 lines

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Furthermore, do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

This patch is fixing 2 things. But only the memcmp issue need to be backported to stable. I would prefer to split this into 2 and mark only the memcmp commit to be backported.

Hi David,
Do you have a different opinion here?

Quoted 146 lines
Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 59 ++++++++++++++++++++------------------------
 1 file changed, 27 insertions(+), 32 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

811adc523..4a2bd39fc 100644

app/test/test_ring.c +14 -0
@@ -258,6 +258,21 @@ test_ring_mem_init(void *obj, unsigned int count, int
 esize)
 			((uint32_t *)obj)[i] = i;
 }
 
+static int
+test_ring_mem_cmp(void *src, void *dst, unsigned int size) {
+	int ret;
+
+	ret = memcmp(src, dst, size);
+	if (ret) {
+		rte_hexdump(stdout, "src", src, size);
+		rte_hexdump(stdout, "dst", dst, size);
+		printf("data after dequeue is not the same\n");
+	}
+
+	return ret;
+}
+
 static void
 test_ring_print_test_string(const char *istr, unsigned int api_type, int esize)

{ @@ -383,7 +398,7 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)

app/test/test_ring.c +6 -2
 	struct rte_ring *r;
 	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	int ret;
-	unsigned int i, j;
+	unsigned int i, j, temp_sz;
 	int rand;
 	const unsigned int rsz = RING_SIZE - 1;
@@ -444,7 +459,11 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			temp_sz = rsz * sizeof(void *);
+			if (esize[i] != -1)
+				temp_sz = rsz * esize[i];
+			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+						temp_sz) == 0);
 		}
 
 		/* Free memory before test completed */ @@ -538,12 +557,8

@@ test_ring_burst_bulk_tests2(unsigned int test_idx)

app/test/test_ring.c +6 -31
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -614,12 +629,8 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -747,12 +758,8 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -857,12 +864,8 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_src - src)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_src, src)))
 			goto fail_test;
-		}
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -909,12 +912,8 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -1047,12 +1046,8 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto test_fail;
-		}
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
--

2.17.1

#37 lore raw

Re: [dpdk-dev] [PATCH v3 5/6] test/ring: fix wrong size used in memcmp

Quoted 11 lines · Honnappa Nagarahalli

<snip>

Quoted 7 lines

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Furthermore, do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

This patch is fixing 2 things. But only the memcmp issue need to be backported to stable. I would prefer to split this into 2 and mark only the memcmp commit to be backported.

+1

Signature · 1 line
David Marchand
#38 lore raw

PATCH v3 6/6 test/ring: improve the application of macro

In reply to Feifei Wang

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Furthermore, replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

---
 app/test/test_ring.c | 264 ++++++++++++++++---------------------------
 1 file changed, 98 insertions(+), 166 deletions(-)
app/test/test_ring.c +98 -166
index 4a2bd39fc..bbfdff4bd 100644
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)						\
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r) do {					\
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		goto fail;						\
+	}								\
+} while (0)
 
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMTPY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -316,7 +326,7 @@ test_ring_negative_tests(void)
 				RING_SIZE + 1, SOCKET_ID_ANY, 0);
 	if (rp != NULL) {
 		printf("Test failed to detect invalid element size\n");
-		goto test_fail;
+		goto fail;
 	}
 
 
@@ -326,7 +336,7 @@ test_ring_negative_tests(void)
 					RING_SIZE + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect odd count\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test if ring size is exceeding the limit */
@@ -334,14 +344,14 @@ test_ring_negative_tests(void)
 					RTE_RING_SZ_MASK + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect limits\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Tests if lookup returns NULL on non-existing ring */
 		rp = rte_ring_lookup("ring_not_found");
 		if (rp != NULL && rte_errno != ENOENT) {
 			printf("Test failed to detect NULL ring lookup\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test to if a non-power of 2 count causes the create
@@ -350,23 +360,19 @@ test_ring_negative_tests(void)
 		rp = test_ring_create("test_ring_count", esize[i], 4097,
 					SOCKET_ID_ANY, 0);
 		if (rp != NULL)
-			goto test_fail;
+			goto fail;
 
 		rp = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("test_ring_negative fail to create ring\n");
-			goto test_fail;
+			goto fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it should be\n");
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -374,7 +380,7 @@ test_ring_negative_tests(void)
 		rt = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY, 0);
 		if (rt != NULL)
-			goto test_fail;
+			goto fail;
 
 		rte_ring_free(rp);
 		rp = NULL;
@@ -382,7 +388,7 @@ test_ring_negative_tests(void)
 
 	return 0;
 
-test_fail:
+fail:
 
 	rte_ring_free(rp);
 	return -1;
@@ -433,37 +439,38 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r);
+			TEST_RING_VERIFY(rte_ring_full(r), r);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_empty(r), r);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r);
 		}
 
 		/* Free memory before test completed */
@@ -520,45 +527,39 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -615,22 +616,20 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -690,16 +689,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");
@@ -711,34 +708,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r);
 
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */
@@ -748,18 +740,16 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -795,14 +785,14 @@ test_ring_basic_ex(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("%s: failed to create ring\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 
 		/* alloc dummy object pointers */
 		src = test_ring_calloc(RING_SIZE, esize[i]);
 		if (src == NULL) {
 			printf("%s: failed to alloc src memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		test_ring_mem_init(src, RING_SIZE, esize[i]);
 		cur_src = src;
@@ -811,20 +801,13 @@ test_ring_basic_ex(void)
 		dst = test_ring_calloc(RING_SIZE, esize[i]);
 		if (dst == NULL) {
 			printf("%s: failed to alloc dst memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
@@ -832,40 +815,24 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_src, src)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -880,40 +847,28 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -925,7 +880,7 @@ test_ring_basic_ex(void)
 
 	return 0;
 
-fail_test:
+fail:
 	rte_ring_free(rp);
 	rte_free(src);
 	rte_free(dst);
@@ -955,7 +910,7 @@ test_ring_with_exact_size(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (std_r == NULL) {
 			printf("%s: error, can't create std ring\n", __func__);
-			goto test_fail;
+			goto fail;
 		}
 		exact_sz_r = test_ring_create("exact sz", esize[i], ring_sz,
 				rte_socket_id(),
@@ -964,7 +919,7 @@ test_ring_with_exact_size(void)
 		if (exact_sz_r == NULL) {
 			printf("%s: error, can't create exact size ring\n",
 					__func__);
-			goto test_fail;
+			goto fail;
 		}
 
 		/* alloc object pointers. Allocate one extra object
@@ -972,14 +927,14 @@ test_ring_with_exact_size(void)
 		 */
 		src_orig = test_ring_calloc(17, esize[i]);
 		if (src_orig == NULL)
-			goto test_fail;
+			goto fail;
 		test_ring_mem_init(src_orig, 17, esize[i]);
 		src = (void **)((uintptr_t)src_orig + 1);
 		cur_src = src;
 
 		dst_orig = test_ring_calloc(17, esize[i]);
 		if (dst_orig == NULL)
-			goto test_fail;
+			goto fail;
 		dst = (void **)((uintptr_t)dst_orig + 1);
 		cur_dst = dst;
 
@@ -987,13 +942,9 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r), std_r);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements)
@@ -1001,53 +952,34 @@ test_ring_with_exact_size(void)
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of elements\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) == ring_sz,
+					exact_sz_r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
@@ -1061,7 +993,7 @@ test_ring_with_exact_size(void)
 
 	return 0;
 
-test_fail:
+fail:
 	rte_free(src_orig);
 	rte_free(dst_orig);
 	rte_ring_free(std_r);
Signature · 1 line
2.17.1
#39 lore raw

v4 cover fix wrong passed pointer and add check

In reply to Feifei Wang

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

v3:
1. Adjust the 'check dequeued objects' patch from the last to the first in the series. (Honnappa)
2. Add the new function 'test_ring_mem_cmp to replace 'memset' and print information of enqueue/dequeue elements if validation fails. (Honnappa)
3. Add test to validate the whether the enqueue and dequeue operation is successful for each time. (Honnappa)
4. Expand the scope of application for the macro TEST_RING_VERIF, and replace all ring APIs check with this macro. (Honnappa)

v4:
1. Split the 'memcmp' bug fix patch into two patches, one is memcmp issue patch, the other is to add new function 'test_ring_mem_cmp'. (Honnappa)

Feifei Wang (7):
test/ring: add check to validate dequeued objects test/ring: fix wrong parameter passed to the enqueue APIs test/ring: validate the return value of enq/deq elements test/ring: fix wrong number of enq/deq elements test/ring: fix wrong size used in memcmp test/ring: add new function to validate dequeue data test/ring: improve the application of macro

 app/test/test_ring.c | 384 ++++++++++++++++++++++---------------------
 app/test/test_ring.h |   6 +-
 2 files changed, 199 insertions(+), 191 deletions(-)
Signature · 1 line
2.17.1
#40 lore raw

PATCH v4 1/7 test/ring: add check to validate dequeued objects

Add check in test_ring_basic_ex and test_ring_with_exact_size for single element enqueue and dequeue operations to validate the dequeued objects.

---
 app/test/test_ring.c | 135 +++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 36 deletions(-)
app/test/test_ring.c +99 -36
index 0ae97d341..6e48cc0b1 100644
@@ -780,15 +780,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -797,6 +791,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -812,8 +823,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
 		if (rte_ring_full(rp) != 1) {
@@ -823,8 +835,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
 		if (rte_ring_empty(rp) != 1) {
@@ -833,52 +846,80 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, cur_src - src)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset memory of dst */
+		memset(dst, 0, RTE_PTR_DIFF(cur_src, src));
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
 
@@ -889,8 +930,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -900,14 +941,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -925,6 +958,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = (void **)((uintptr_t)src_orig + 1);
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = (void **)((uintptr_t)dst_orig + 1);
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -941,33 +990,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of elements\n",
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
@@ -976,10 +1028,20 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, cur_dst - dst)) {
+			rte_hexdump(stdout, "src", src, cur_src - src);
+			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -987,7 +1049,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
Signature · 1 line
2.17.1
#41 lore raw

PATCH v4 2/7 test/ring: fix wrong parameter passed to the enqueue APIs

In reply to Feifei Wang

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
#42 lore raw

PATCH v4 3/7 test/ring: validate the return value of enq/deq elements

In reply to Feifei Wang

Validate the return value of single element enqueue/dequeue operation in the test.

---
 app/test/test_ring.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)
app/test/test_ring.c +22 -4
index 6e48cc0b1..63d44d85e 100644
@@ -823,8 +823,13 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_enqueue(rp, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_enqueue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
@@ -835,8 +840,13 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE; j++) {
-			test_ring_dequeue(rp, cur_dst, esize[i], 1,
+			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_dequeue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
@@ -990,10 +1000,18 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
+			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
Signature · 1 line
2.17.1
#43 lore raw

PATCH v4 4/7 test/ring: fix wrong number of enq/deq elements

In reply to Feifei Wang

The ring capacity is (RING_SIZE - 1), thus only (RING_SIZE - 1) number of elements can be enqueued into the ring.

Fixes af75078fece3 ("first public release")
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c +2 -2
index 63d44d85e..811adc523 100644
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 			if (ret != 0) {
@@ -839,7 +839,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 			if (ret != 0) {
Signature · 1 line
2.17.1
#44 lore raw

PATCH v4 5/7 test/ring: fix wrong size used in memcmp

In reply to Feifei Wang

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 49 +++++++++++++++++++++++++++-----------------
 1 file changed, 30 insertions(+), 19 deletions(-)
app/test/test_ring.c +30 -19
index 811adc523..06498c337 100644
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -538,9 +543,11 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -857,9 +868,9 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_src - src)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_src, src))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail_test;
 		}
@@ -909,9 +920,9 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail_test;
 		}
@@ -1047,9 +1058,9 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto test_fail;
 		}
Signature · 1 line
2.17.1
#45 lore raw

PATCH v4 6/7 test/ring: add new function to validate dequeue data

In reply to Feifei Wang

Do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

---
 app/test/test_ring.c | 70 +++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 43 deletions(-)
app/test/test_ring.c +27 -43
index 06498c337..4a2bd39fc 100644
@@ -258,6 +258,21 @@ test_ring_mem_init(void *obj, unsigned int count, int esize)
 			((uint32_t *)obj)[i] = i;
 }
 
+static int
+test_ring_mem_cmp(void *src, void *dst, unsigned int size)
+{
+	int ret;
+
+	ret = memcmp(src, dst, size);
+	if (ret) {
+		rte_hexdump(stdout, "src", src, size);
+		rte_hexdump(stdout, "dst", dst, size);
+		printf("data after dequeue is not the same\n");
+	}
+
+	return ret;
+}
+
 static void
 test_ring_print_test_string(const char *istr, unsigned int api_type, int esize)
 {
@@ -383,7 +398,7 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 	struct rte_ring *r;
 	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	int ret;
-	unsigned int i, j;
+	unsigned int i, j, temp_sz;
 	int rand;
 	const unsigned int rsz = RING_SIZE - 1;
 
@@ -444,12 +459,11 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			if (esize[i] == -1) {
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * sizeof(void *)) == 0);
-			} else
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * esize[i]) == 0);
+			temp_sz = rsz * sizeof(void *);
+			if (esize[i] != -1)
+				temp_sz = rsz * esize[i];
+			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+						temp_sz) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -543,14 +557,8 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -621,14 +629,8 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -756,14 +758,8 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -868,12 +864,8 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_src, src))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_src, src)))
 			goto fail_test;
-		}
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -920,12 +912,8 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -1058,12 +1046,8 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto test_fail;
-		}
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
Signature · 1 line
2.17.1
#46 lore raw

PATCH v4 7/7 test/ring: improve the application of macro

In reply to Feifei Wang

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Furthermore, replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

Furthermore, correct a spelling mistakes of the macro TEST_RING_FULL_EMTPY_ITER.

---
 app/test/test_ring.c | 266 ++++++++++++++++---------------------------
 1 file changed, 99 insertions(+), 167 deletions(-)
app/test/test_ring.c +99 -167
index 4a2bd39fc..155f75cc4 100644
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)						\
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r) do {					\
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		goto fail;						\
+	}								\
+} while (0)
 
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMPTY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -316,7 +326,7 @@ test_ring_negative_tests(void)
 				RING_SIZE + 1, SOCKET_ID_ANY, 0);
 	if (rp != NULL) {
 		printf("Test failed to detect invalid element size\n");
-		goto test_fail;
+		goto fail;
 	}
 
 
@@ -326,7 +336,7 @@ test_ring_negative_tests(void)
 					RING_SIZE + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect odd count\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test if ring size is exceeding the limit */
@@ -334,14 +344,14 @@ test_ring_negative_tests(void)
 					RTE_RING_SZ_MASK + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect limits\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Tests if lookup returns NULL on non-existing ring */
 		rp = rte_ring_lookup("ring_not_found");
 		if (rp != NULL && rte_errno != ENOENT) {
 			printf("Test failed to detect NULL ring lookup\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test to if a non-power of 2 count causes the create
@@ -350,23 +360,19 @@ test_ring_negative_tests(void)
 		rp = test_ring_create("test_ring_count", esize[i], 4097,
 					SOCKET_ID_ANY, 0);
 		if (rp != NULL)
-			goto test_fail;
+			goto fail;
 
 		rp = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("test_ring_negative fail to create ring\n");
-			goto test_fail;
+			goto fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it should be\n");
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -374,7 +380,7 @@ test_ring_negative_tests(void)
 		rt = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY, 0);
 		if (rt != NULL)
-			goto test_fail;
+			goto fail;
 
 		rte_ring_free(rp);
 		rp = NULL;
@@ -382,7 +388,7 @@ test_ring_negative_tests(void)
 
 	return 0;
 
-test_fail:
+fail:
 
 	rte_ring_free(rp);
 	return -1;
@@ -426,44 +432,45 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 
 		printf("Random full/empty test\n");
 
-		for (j = 0; j != TEST_RING_FULL_EMTPY_ITER; j++) {
+		for (j = 0; j != TEST_RING_FULL_EMPTY_ITER; j++) {
 			/* random shift in the ring */
 			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 			printf("%s: iteration %u, random shift: %u;\n",
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r);
+			TEST_RING_VERIFY(rte_ring_full(r), r);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_empty(r), r);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r);
 		}
 
 		/* Free memory before test completed */
@@ -520,45 +527,39 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -615,22 +616,20 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -690,16 +689,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");
@@ -711,34 +708,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r);
 
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */
@@ -748,18 +740,16 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -795,14 +785,14 @@ test_ring_basic_ex(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("%s: failed to create ring\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 
 		/* alloc dummy object pointers */
 		src = test_ring_calloc(RING_SIZE, esize[i]);
 		if (src == NULL) {
 			printf("%s: failed to alloc src memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		test_ring_mem_init(src, RING_SIZE, esize[i]);
 		cur_src = src;
@@ -811,20 +801,13 @@ test_ring_basic_ex(void)
 		dst = test_ring_calloc(RING_SIZE, esize[i]);
 		if (dst == NULL) {
 			printf("%s: failed to alloc dst memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
@@ -832,40 +815,24 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_src, src)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -880,40 +847,28 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -925,7 +880,7 @@ test_ring_basic_ex(void)
 
 	return 0;
 
-fail_test:
+fail:
 	rte_ring_free(rp);
 	rte_free(src);
 	rte_free(dst);
@@ -955,7 +910,7 @@ test_ring_with_exact_size(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (std_r == NULL) {
 			printf("%s: error, can't create std ring\n", __func__);
-			goto test_fail;
+			goto fail;
 		}
 		exact_sz_r = test_ring_create("exact sz", esize[i], ring_sz,
 				rte_socket_id(),
@@ -964,7 +919,7 @@ test_ring_with_exact_size(void)
 		if (exact_sz_r == NULL) {
 			printf("%s: error, can't create exact size ring\n",
 					__func__);
-			goto test_fail;
+			goto fail;
 		}
 
 		/* alloc object pointers. Allocate one extra object
@@ -972,14 +927,14 @@ test_ring_with_exact_size(void)
 		 */
 		src_orig = test_ring_calloc(17, esize[i]);
 		if (src_orig == NULL)
-			goto test_fail;
+			goto fail;
 		test_ring_mem_init(src_orig, 17, esize[i]);
 		src = (void **)((uintptr_t)src_orig + 1);
 		cur_src = src;
 
 		dst_orig = test_ring_calloc(17, esize[i]);
 		if (dst_orig == NULL)
-			goto test_fail;
+			goto fail;
 		dst = (void **)((uintptr_t)dst_orig + 1);
 		cur_dst = dst;
 
@@ -987,13 +942,9 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r), std_r);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements)
@@ -1001,53 +952,34 @@ test_ring_with_exact_size(void)
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of elements\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) == ring_sz,
+					exact_sz_r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
@@ -1061,7 +993,7 @@ test_ring_with_exact_size(void)
 
 	return 0;
 
-test_fail:
+fail:
 	rte_free(src_orig);
 	rte_free(dst_orig);
 	rte_ring_free(std_r);
Signature · 1 line
2.17.1
#47 lore raw

v5 cover fix wrong passed pointer and add check

In reply to Feifei Wang

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

v3:
1. Adjust the 'check dequeued objects' patch from the last to the first in the series. (Honnappa)
2. Add the new function 'test_ring_mem_cmp to replace 'memset' and print information of enqueue/dequeue elements if validation fails. (Honnappa)
3. Add test to validate the whether the enqueue and dequeue operation is successful for each time. (Honnappa)
4. Expand the scope of application for the macro TEST_RING_VERIF, and replace all ring APIs check with this macro. (Honnappa)

v4:
1. Split the 'memcmp' bug fix patch into two patches, one is memcmp issue patch, the other is to add new function 'test_ring_mem_cmp'. (Honnappa)

v5:
1. Adjust bug fixed patches to the first of the series, to ensure that the back porting will go smooth. (Honnappa)

Feifei Wang (7):
test/ring: fix wrong parameter passed to the enqueue APIs test/ring: fix wrong number of enq/deq elements test/ring: fix wrong size used in memcmp test/ring: add check to validate dequeued objects test/ring: validate the return value of enq/deq elements test/ring: add new function to validate dequeue data test/ring: improve the application of macro

 app/test/test_ring.c | 384 ++++++++++++++++++++++---------------------
 app/test/test_ring.h |   6 +-
 2 files changed, 199 insertions(+), 191 deletions(-)
Signature · 1 line
2.17.1
#48 lore raw

PATCH v5 1/7 test/ring: fix wrong parameter passed to the enqueue APIs

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
#49 lore raw

PATCH v5 2/7 test/ring: fix wrong number of enq/deq elements

In reply to Feifei Wang

The ring capacity is (RING_SIZE - 1), thus only (RING_SIZE - 1) number of elements can be enqueued into the ring.

Fixes af75078fece3 ("first public release")
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c +2 -2
index 0ae97d341..04bdc9b69 100644
@@ -811,7 +811,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_enqueue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_dequeue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
Signature · 1 line
2.17.1
#50 lore raw

PATCH v5 3/7 test/ring: fix wrong size used in memcmp

In reply to Feifei Wang

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)
app/test/test_ring.c +21 -10
index 04bdc9b69..51bae0d48 100644
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -538,9 +543,11 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
Signature · 1 line
2.17.1
#51 lore raw

PATCH v5 4/7 test/ring: add check to validate dequeued objects

In reply to Feifei Wang

Add check in test_ring_basic_ex and test_ring_with_exact_size for single element enqueue and dequeue operations to validate the dequeued objects.

---
 app/test/test_ring.c | 135 +++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 36 deletions(-)
app/test/test_ring.c +99 -36
index 51bae0d48..c9017793a 100644
@@ -791,15 +791,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -808,6 +802,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -823,8 +834,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
 		if (rte_ring_full(rp) != 1) {
@@ -834,8 +846,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
 		if (rte_ring_empty(rp) != 1) {
@@ -844,52 +857,80 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset memory of dst */
+		memset(dst, 0, RTE_PTR_DIFF(cur_dst, dst));
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
 
@@ -900,8 +941,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -911,14 +952,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -936,6 +969,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = (void **)((uintptr_t)src_orig + 1);
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = (void **)((uintptr_t)dst_orig + 1);
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -952,33 +1001,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of elements\n",
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
@@ -987,10 +1039,20 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -998,7 +1060,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
Signature · 1 line
2.17.1
#52 lore raw

PATCH v5 5/7 test/ring: validate the return value of enq/deq elements

In reply to Feifei Wang

Validate the return value of single element enqueue/dequeue operation in the test.

---
 app/test/test_ring.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)
app/test/test_ring.c +22 -4
index c9017793a..da57032c7 100644
@@ -834,8 +834,13 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_enqueue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
@@ -846,8 +851,13 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, cur_dst, esize[i], 1,
+			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_dequeue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
@@ -1001,10 +1011,18 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
+			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
Signature · 1 line
2.17.1
#53 lore raw

PATCH v5 6/7 test/ring: add new function to validate dequeue data

In reply to Feifei Wang

Do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

---
 app/test/test_ring.c | 70 +++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 43 deletions(-)
app/test/test_ring.c +27 -43
index da57032c7..fb46614f8 100644
@@ -258,6 +258,21 @@ test_ring_mem_init(void *obj, unsigned int count, int esize)
 			((uint32_t *)obj)[i] = i;
 }
 
+static int
+test_ring_mem_cmp(void *src, void *dst, unsigned int size)
+{
+	int ret;
+
+	ret = memcmp(src, dst, size);
+	if (ret) {
+		rte_hexdump(stdout, "src", src, size);
+		rte_hexdump(stdout, "dst", dst, size);
+		printf("data after dequeue is not the same\n");
+	}
+
+	return ret;
+}
+
 static void
 test_ring_print_test_string(const char *istr, unsigned int api_type, int esize)
 {
@@ -383,7 +398,7 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 	struct rte_ring *r;
 	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	int ret;
-	unsigned int i, j;
+	unsigned int i, j, temp_sz;
 	int rand;
 	const unsigned int rsz = RING_SIZE - 1;
 
@@ -444,12 +459,11 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			if (esize[i] == -1) {
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * sizeof(void *)) == 0);
-			} else
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * esize[i]) == 0);
+			temp_sz = rsz * sizeof(void *);
+			if (esize[i] != -1)
+				temp_sz = rsz * esize[i];
+			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+						temp_sz) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -543,14 +557,8 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -621,14 +629,8 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -756,14 +758,8 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -868,12 +864,8 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -920,12 +912,8 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -1058,12 +1046,8 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto test_fail;
-		}
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
Signature · 1 line
2.17.1
#54 lore raw

PATCH v5 7/7 test/ring: improve the application of macro

In reply to Feifei Wang

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Then replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

Furthermore, correct a spelling mistakes of the macro TEST_RING_FULL_EMTPY_ITER.

---
 app/test/test_ring.c | 266 ++++++++++++++++---------------------------
 1 file changed, 99 insertions(+), 167 deletions(-)
app/test/test_ring.c +99 -167
index fb46614f8..605b620ce 100644
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)						\
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r) do {					\
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		goto fail;						\
+	}								\
+} while (0)
 
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMPTY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -316,7 +326,7 @@ test_ring_negative_tests(void)
 				RING_SIZE + 1, SOCKET_ID_ANY, 0);
 	if (rp != NULL) {
 		printf("Test failed to detect invalid element size\n");
-		goto test_fail;
+		goto fail;
 	}
 
 
@@ -326,7 +336,7 @@ test_ring_negative_tests(void)
 					RING_SIZE + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect odd count\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test if ring size is exceeding the limit */
@@ -334,14 +344,14 @@ test_ring_negative_tests(void)
 					RTE_RING_SZ_MASK + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect limits\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Tests if lookup returns NULL on non-existing ring */
 		rp = rte_ring_lookup("ring_not_found");
 		if (rp != NULL && rte_errno != ENOENT) {
 			printf("Test failed to detect NULL ring lookup\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test to if a non-power of 2 count causes the create
@@ -350,23 +360,19 @@ test_ring_negative_tests(void)
 		rp = test_ring_create("test_ring_count", esize[i], 4097,
 					SOCKET_ID_ANY, 0);
 		if (rp != NULL)
-			goto test_fail;
+			goto fail;
 
 		rp = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("test_ring_negative fail to create ring\n");
-			goto test_fail;
+			goto fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it should be\n");
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -374,7 +380,7 @@ test_ring_negative_tests(void)
 		rt = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY, 0);
 		if (rt != NULL)
-			goto test_fail;
+			goto fail;
 
 		rte_ring_free(rp);
 		rp = NULL;
@@ -382,7 +388,7 @@ test_ring_negative_tests(void)
 
 	return 0;
 
-test_fail:
+fail:
 
 	rte_ring_free(rp);
 	return -1;
@@ -426,44 +432,45 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 
 		printf("Random full/empty test\n");
 
-		for (j = 0; j != TEST_RING_FULL_EMTPY_ITER; j++) {
+		for (j = 0; j != TEST_RING_FULL_EMPTY_ITER; j++) {
 			/* random shift in the ring */
 			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 			printf("%s: iteration %u, random shift: %u;\n",
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r);
+			TEST_RING_VERIFY(rte_ring_full(r), r);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_empty(r), r);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r);
 		}
 
 		/* Free memory before test completed */
@@ -520,45 +527,39 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -615,22 +616,20 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -690,16 +689,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");
@@ -711,34 +708,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r);
 
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */
@@ -748,18 +740,16 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -795,14 +785,14 @@ test_ring_basic_ex(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("%s: failed to create ring\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 
 		/* alloc dummy object pointers */
 		src = test_ring_calloc(RING_SIZE, esize[i]);
 		if (src == NULL) {
 			printf("%s: failed to alloc src memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		test_ring_mem_init(src, RING_SIZE, esize[i]);
 		cur_src = src;
@@ -811,20 +801,13 @@ test_ring_basic_ex(void)
 		dst = test_ring_calloc(RING_SIZE, esize[i]);
 		if (dst == NULL) {
 			printf("%s: failed to alloc dst memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
@@ -832,40 +815,24 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -880,40 +847,28 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -925,7 +880,7 @@ test_ring_basic_ex(void)
 
 	return 0;
 
-fail_test:
+fail:
 	rte_ring_free(rp);
 	rte_free(src);
 	rte_free(dst);
@@ -955,7 +910,7 @@ test_ring_with_exact_size(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (std_r == NULL) {
 			printf("%s: error, can't create std ring\n", __func__);
-			goto test_fail;
+			goto fail;
 		}
 		exact_sz_r = test_ring_create("exact sz", esize[i], ring_sz,
 				rte_socket_id(),
@@ -964,7 +919,7 @@ test_ring_with_exact_size(void)
 		if (exact_sz_r == NULL) {
 			printf("%s: error, can't create exact size ring\n",
 					__func__);
-			goto test_fail;
+			goto fail;
 		}
 
 		/* alloc object pointers. Allocate one extra object
@@ -972,14 +927,14 @@ test_ring_with_exact_size(void)
 		 */
 		src_orig = test_ring_calloc(17, esize[i]);
 		if (src_orig == NULL)
-			goto test_fail;
+			goto fail;
 		test_ring_mem_init(src_orig, 17, esize[i]);
 		src = (void **)((uintptr_t)src_orig + 1);
 		cur_src = src;
 
 		dst_orig = test_ring_calloc(17, esize[i]);
 		if (dst_orig == NULL)
-			goto test_fail;
+			goto fail;
 		dst = (void **)((uintptr_t)dst_orig + 1);
 		cur_dst = dst;
 
@@ -987,13 +942,9 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r), std_r);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements)
@@ -1001,53 +952,34 @@ test_ring_with_exact_size(void)
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of elements\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) == ring_sz,
+					exact_sz_r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
@@ -1061,7 +993,7 @@ test_ring_with_exact_size(void)
 
 	return 0;
 
-test_fail:
+fail:
 	rte_free(src_orig);
 	rte_free(dst_orig);
 	rte_ring_free(std_r);
Signature · 1 line
2.17.1
#55 lore raw

Re: [dpdk-dev] [PATCH v5 7/7] test/ring: improve the application of macro

Quoted 37 lines

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Then replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

Furthermore, correct a spelling mistakes of the macro TEST_RING_FULL_EMTPY_ITER.

---
 app/test/test_ring.c | 266 ++++++++++++++++---------------------------
 1 file changed, 99 insertions(+), 167 deletions(-)
app/test/test_ring.c +10 -1
index fb46614f8..605b620ce 100644
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)						\
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r) do {					\

app/test/test_ring.c line 65

Quoted 10 lines
app/test/test_ring.c +4 -3
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		goto fail;						\
+	}								\
+} while (0)

LGTM, just one suggestion for the macro above:
Instead of arrange the whole code with the same label, why not to simply add control transfer statement as extra parameter to the macro:

#define TEST_RING_VERIFY(exp, r, errst) do { \
if (!(exp)) { \
printf("error at %s:%d\tcondition " #exp " failed\n", \

  		    __func__, __LINE__);				\
		rte_ring_dump(stdout, r);				\
		errst;						\
	}
								\
} while (0)

Ans then just:
TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r, return -1); or
TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r, goto fail); or whatever is appropriate.

With that said:
Series acked-by: Konstantin Ananyev <[email protected]>

Quoted 581 lines
app/test/test_ring.c +85 -164
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMPTY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -316,7 +326,7 @@ test_ring_negative_tests(void)
 				RING_SIZE + 1, SOCKET_ID_ANY, 0);
 	if (rp != NULL) {
 		printf("Test failed to detect invalid element size\n");
-		goto test_fail;
+		goto fail;
 	}
 
 
@@ -326,7 +336,7 @@ test_ring_negative_tests(void)
 					RING_SIZE + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect odd count\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test if ring size is exceeding the limit */
@@ -334,14 +344,14 @@ test_ring_negative_tests(void)
 					RTE_RING_SZ_MASK + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect limits\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Tests if lookup returns NULL on non-existing ring */
 		rp = rte_ring_lookup("ring_not_found");
 		if (rp != NULL && rte_errno != ENOENT) {
 			printf("Test failed to detect NULL ring lookup\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test to if a non-power of 2 count causes the create
@@ -350,23 +360,19 @@ test_ring_negative_tests(void)
 		rp = test_ring_create("test_ring_count", esize[i], 4097,
 					SOCKET_ID_ANY, 0);
 		if (rp != NULL)
-			goto test_fail;
+			goto fail;
 
 		rp = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("test_ring_negative fail to create ring\n");
-			goto test_fail;
+			goto fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it should be\n");
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -374,7 +380,7 @@ test_ring_negative_tests(void)
 		rt = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY, 0);
 		if (rt != NULL)
-			goto test_fail;
+			goto fail;
 
 		rte_ring_free(rp);
 		rp = NULL;
@@ -382,7 +388,7 @@ test_ring_negative_tests(void)
 
 	return 0;
 
-test_fail:
+fail:
 
 	rte_ring_free(rp);
 	return -1;
@@ -426,44 +432,45 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 
 		printf("Random full/empty test\n");
 
-		for (j = 0; j != TEST_RING_FULL_EMTPY_ITER; j++) {
+		for (j = 0; j != TEST_RING_FULL_EMPTY_ITER; j++) {
 			/* random shift in the ring */
 			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 			printf("%s: iteration %u, random shift: %u;\n",
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r);
+			TEST_RING_VERIFY(rte_ring_full(r), r);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_empty(r), r);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r);
 		}
 
 		/* Free memory before test completed */
@@ -520,45 +527,39 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -615,22 +616,20 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -690,16 +689,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");
@@ -711,34 +708,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r);
 
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */
@@ -748,18 +740,16 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -795,14 +785,14 @@ test_ring_basic_ex(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("%s: failed to create ring\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 
 		/* alloc dummy object pointers */
 		src = test_ring_calloc(RING_SIZE, esize[i]);
 		if (src == NULL) {
 			printf("%s: failed to alloc src memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		test_ring_mem_init(src, RING_SIZE, esize[i]);
 		cur_src = src;
@@ -811,20 +801,13 @@ test_ring_basic_ex(void)
 		dst = test_ring_calloc(RING_SIZE, esize[i]);
 		if (dst == NULL) {
 			printf("%s: failed to alloc dst memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") == rp, rp);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
@@ -832,40 +815,24 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -880,40 +847,28 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -925,7 +880,7 @@ test_ring_basic_ex(void)
 
 	return 0;
 
-fail_test:
+fail:
 	rte_ring_free(rp);
 	rte_free(src);
 	rte_free(dst);
@@ -955,7 +910,7 @@ test_ring_with_exact_size(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (std_r == NULL) {
 			printf("%s: error, can't create std ring\n", __func__);
-			goto test_fail;
+			goto fail;
 		}
 		exact_sz_r = test_ring_create("exact sz", esize[i], ring_sz,
 				rte_socket_id(),
@@ -964,7 +919,7 @@ test_ring_with_exact_size(void)
 		if (exact_sz_r == NULL) {
 			printf("%s: error, can't create exact size ring\n",
 					__func__);
-			goto test_fail;
+			goto fail;
 		}
 
 		/* alloc object pointers. Allocate one extra object
@@ -972,14 +927,14 @@ test_ring_with_exact_size(void)
 		 */
 		src_orig = test_ring_calloc(17, esize[i]);
 		if (src_orig == NULL)
-			goto test_fail;
+			goto fail;
 		test_ring_mem_init(src_orig, 17, esize[i]);
 		src = (void **)((uintptr_t)src_orig + 1);
 		cur_src = src;
 
 		dst_orig = test_ring_calloc(17, esize[i]);
 		if (dst_orig == NULL)
-			goto test_fail;
+			goto fail;
 		dst = (void **)((uintptr_t)dst_orig + 1);
 		cur_dst = dst;
 
@@ -987,13 +942,9 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r), std_r);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements)
@@ -1001,53 +952,34 @@ test_ring_with_exact_size(void)
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of elements\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) == ring_sz,
+					exact_sz_r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
@@ -1061,7 +993,7 @@ test_ring_with_exact_size(void)
 
 	return 0;
 
-test_fail:
+fail:
 	rte_free(src_orig);
 	rte_free(dst_orig);
 	rte_ring_free(std_r);
--

2.17.1

#56 lore raw

[dpdk-dev] 回复: [PATCH v5 7/7] test/ring: improve the application of macro

Hi, Konstantin

Quoted 74 lines

-----邮件原件-----
发件人: Ananyev, Konstantin <[email protected]> 发送时间: 2020年9月18日 0:26
收件人: Feifei Wang <[email protected]>; Honnappa Nagarahalli <[email protected]>
抄送: [email protected]; nd <[email protected]>
主题: RE: [PATCH v5 7/7] test/ring: improve the application of macro

Quoted 22 lines

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Then replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

Furthermore, correct a spelling mistakes of the macro TEST_RING_FULL_EMTPY_ITER.

---
 app/test/test_ring.c | 266
++++++++++++++++---------------------------
 1 file changed, 99 insertions(+), 167 deletions(-)
app/test/test_ring.c index renamed from app/test/test_ring.c +0 -0

fb46614f8..605b620ce 100644

app/test/test_ring.c line 49

Quoted 4 lines
app/test/test_ring.c +0 -1
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)
		\

app/test/test_ring.c

Quoted 10 lines
app/test/test_ring.c +10 -0
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r) do {
	\

app/test/test_ring.c line 65

Quoted 10 lines
app/test/test_ring.c +4 -3
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		goto fail;						\
+	}								\
+} while (0)

LGTM, just one suggestion for the macro above:
Instead of arrange the whole code with the same label, why not to simply add control transfer statement as extra parameter to the macro:

#define TEST_RING_VERIFY(exp, r, errst) do {
	\
  	if (!(exp)) {							\
  		printf("error at %s:%d\tcondition " #exp " failed\n",	\
  		    __func__, __LINE__);				\
		rte_ring_dump(stdout, r);				\
		errst;						\
	}
								\
} while (0)
Quoted 8 lines

Ans then just:
TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r, return -1); or TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r, goto fail); or whatever is appropriate.

With that said:
Series acked-by: Konstantin Ananyev <[email protected]>

Thanks for your advice, the new version with this change has just been updated.

Quoted 611 lines
Quoted 16 lines
app/test/test_ring.c +2 -2
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMPTY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -316,7 +326,7 @@ test_ring_negative_tests(void)
 				RING_SIZE + 1, SOCKET_ID_ANY, 0);
 	if (rp != NULL) {
 		printf("Test failed to detect invalid element size\n");
-		goto test_fail;
+		goto fail;
 	}
 
 

app/test/test_ring.c test_ring_negative_tests(void) · line 342

Quoted 8 lines
app/test/test_ring.c +1 -1
@@ -326,7 +336,7 @@ test_ring_negative_tests(void)
 					RING_SIZE + 1, SOCKET_ID_ANY, 0);
 		if (rp != NULL) {
 			printf("Test failed to detect odd count\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test if ring size is exceeding the limit */ @@ -334,14

+344,14

Quoted 2 lines

@@ test_ring_negative_tests(void)
RTE_RING_SZ_MASK + 1,

SOCKET_ID_ANY, 0);

Quoted 5 lines
app/test/test_ring.c +1 -1
 		if (rp != NULL) {
 			printf("Test failed to detect limits\n");
-			goto test_fail;
+			goto fail;
 		}

app/test/test_ring.c test_ring_negative_tests(void)

Quoted 10 lines
app/test/test_ring.c +1 -1
 
 		/* Tests if lookup returns NULL on non-existing ring */
 		rp = rte_ring_lookup("ring_not_found");
 		if (rp != NULL && rte_errno != ENOENT) {
 			printf("Test failed to detect NULL ring lookup\n");
-			goto test_fail;
+			goto fail;
 		}
 
 		/* Test to if a non-power of 2 count causes the create @@ -

350,23

Quoted 9 lines

+360,19 @@ test_ring_negative_tests(void)

app/test/test_ring.c +1 -1
 		rp = test_ring_create("test_ring_count", esize[i], 4097,
 					SOCKET_ID_ANY, 0);
 		if (rp != NULL)
-			goto test_fail;
+			goto fail;
 
 		rp = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,

app/test/test_ring.c test_ring_negative_tests(void)

Quoted 10 lines
app/test/test_ring.c +2 -3
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("test_ring_negative fail to create ring\n");
-			goto test_fail;
+			goto fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") ==

rp, rp);

app/test/test_ring.c

Quoted 3 lines
app/test/test_ring.c +0 -2
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it

should be\n");

Quoted 84 lines
app/test/test_ring.c +18 -18
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -374,7 +380,7 @@ test_ring_negative_tests(void)
 		rt = test_ring_create("test_ring_negative", esize[i], RING_SIZE,
 					SOCKET_ID_ANY, 0);
 		if (rt != NULL)
-			goto test_fail;
+			goto fail;
 
 		rte_ring_free(rp);
 		rp = NULL;
@@ -382,7 +388,7 @@ test_ring_negative_tests(void)
 
 	return 0;
 
-test_fail:
+fail:
 
 	rte_ring_free(rp);
 	return -1;
@@ -426,44 +432,45 @@ test_ring_burst_bulk_tests1(unsigned int
 test_idx)
 
 		printf("Random full/empty test\n");
 
-		for (j = 0; j != TEST_RING_FULL_EMTPY_ITER; j++) {
+		for (j = 0; j != TEST_RING_FULL_EMPTY_ITER; j++) {
 			/* random shift in the ring */
 			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 			printf("%s: iteration %u, random shift: %u;\n",
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r);
+			TEST_RING_VERIFY(rte_ring_full(r), r);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r);
+			TEST_RING_VERIFY(rte_ring_empty(r), r);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r);
 		}
 
Quoted 1 line

/* Free memory before test completed */ @@ -520,45 +527,39

@@

Quoted 55 lines

test_ring_burst_bulk_tests2(unsigned int test_idx)

app/test/test_ring.c +8 -14
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);

app/test/test_ring.c test_ring_burst_bulk_tests3(unsigned int test_idx) · line 617

Quoted 2 lines
app/test/test_ring.c +0 -0
@@ -615,22 +616,20 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i],

MAX_BULK,

app/test/test_ring.c test_ring_burst_bulk_tests3(unsigned int test_idx)

Quoted 8 lines
app/test/test_ring.c +1 -2
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i],

MAX_BULK,

Quoted 17 lines
app/test/test_ring.c +3 -4
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);

app/test/test_ring.c test_ring_burst_bulk_tests4(unsigned int test_idx) · line 690

Quoted 2 lines
app/test/test_ring.c +0 -0
@@ -690,16 +689,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i],

MAX_BULK,

Quoted 6 lines
app/test/test_ring.c +1 -2
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);

app/test/test_ring.c test_ring_burst_bulk_tests4(unsigned int test_idx) · line 702

Quoted 10 lines
app/test/test_ring.c +1 -2
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");

@@

Quoted 14 lines

-711,34 +708,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)

app/test/test_ring.c +2 -4
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r);
 

app/test/test_ring.c test_ring_burst_bulk_tests4(unsigned int test_idx)

Quoted 10 lines
app/test/test_ring.c +1 -2
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i],

MAX_BULK,

Quoted 6 lines
app/test/test_ring.c +1 -2
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);

app/test/test_ring.c test_ring_burst_bulk_tests4(unsigned int test_idx)

Quoted 10 lines
app/test/test_ring.c +1 -2
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */ @@ -

748,18 +740,16

Quoted 44 lines

@@ test_ring_burst_bulk_tests4(unsigned int test_idx)

app/test/test_ring.c +6 -8
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, r);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -795,14 +785,14 @@ test_ring_basic_ex(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (rp == NULL) {
 			printf("%s: failed to create ring\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 
 		/* alloc dummy object pointers */
 		src = test_ring_calloc(RING_SIZE, esize[i]);
 		if (src == NULL) {
 			printf("%s: failed to alloc src memory\n", __func__);
-			goto fail_test;
+			goto fail;
 		}
 		test_ring_mem_init(src, RING_SIZE, esize[i]);
 		cur_src = src;
@@ -811,20 +801,13 @@ test_ring_basic_ex(void)
 		dst = test_ring_calloc(RING_SIZE, esize[i]);
 		if (dst == NULL) {
 			printf("%s: failed to alloc dst memory\n", __func__);

app/test/test_ring.c test_ring_basic_ex(void) · line 808

Quoted 10 lines
app/test/test_ring.c +2 -5
-			goto fail_test;
+			goto fail;
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") ==

rp, rp);

Quoted 11 lines
app/test/test_ring.c +1 -5
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));

app/test/test_ring.c test_ring_basic_ex(void) · line 817

Quoted 3 lines
app/test/test_ring.c +0 -0
@@ -832,40 +815,24 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

Quoted 9 lines
app/test/test_ring.c +1 -5
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 

app/test/test_ring.c test_ring_basic_ex(void)

Quoted 10 lines
app/test/test_ring.c +1 -5
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

Quoted 25 lines
app/test/test_ring.c +4 -12
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.

app/test/test_ring.c test_ring_basic_ex(void) · line 849

Quoted 3 lines
app/test/test_ring.c +0 -0
@@ -880,40 +847,28 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BURST);

app/test/test_ring.c test_ring_basic_ex(void)

Quoted 9 lines
app/test/test_ring.c +1 -4
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BURST);

app/test/test_ring.c test_ring_basic_ex(void)

Quoted 10 lines
app/test/test_ring.c +1 -4
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BULK);

app/test/test_ring.c test_ring_basic_ex(void)

Quoted 9 lines
app/test/test_ring.c +1 -4
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BULK);

Quoted 60 lines
app/test/test_ring.c +9 -11
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0, rp);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -925,7 +880,7 @@ test_ring_basic_ex(void)
 
 	return 0;
 
-fail_test:
+fail:
 	rte_ring_free(rp);
 	rte_free(src);
 	rte_free(dst);
@@ -955,7 +910,7 @@ test_ring_with_exact_size(void)
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
 		if (std_r == NULL) {
 			printf("%s: error, can't create std ring\n", __func__);
-			goto test_fail;
+			goto fail;
 		}
 		exact_sz_r = test_ring_create("exact sz", esize[i], ring_sz,
 				rte_socket_id(),
@@ -964,7 +919,7 @@ test_ring_with_exact_size(void)
 		if (exact_sz_r == NULL) {
 			printf("%s: error, can't create exact size ring\n",
 					__func__);
-			goto test_fail;
+			goto fail;
 		}
 
 		/* alloc object pointers. Allocate one extra object @@ -972,14
+927,14 @@ test_ring_with_exact_size(void)
 		 */
 		src_orig = test_ring_calloc(17, esize[i]);
 		if (src_orig == NULL)
-			goto test_fail;
+			goto fail;
 		test_ring_mem_init(src_orig, 17, esize[i]);
 		src = (void **)((uintptr_t)src_orig + 1);
 		cur_src = src;
 
 		dst_orig = test_ring_calloc(17, esize[i]);
 		if (dst_orig == NULL)
-			goto test_fail;
+			goto fail;
 		dst = (void **)((uintptr_t)dst_orig + 1);
 		cur_dst = dst;

app/test/test_ring.c test_ring_with_exact_size(void) · line 991

Quoted 5 lines
app/test/test_ring.c +0 -2
@@ -987,13 +942,9 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than

exact size one (size %u)\n",

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 11 lines
app/test/test_ring.c +3 -5
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r), std_r);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements) @@ -1001,53

+952,34

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 4 lines

@@ test_ring_with_exact_size(void)

app/test/test_ring.c +0 -0
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 7 lines
app/test/test_ring.c +1 -4
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 9 lines
app/test/test_ring.c +1 -4
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 8 lines
app/test/test_ring.c +1 -5
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_SINGLE);

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 8 lines
app/test/test_ring.c +1 -4
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of

elements */

app/test/test_ring.c

Quoted 2 lines
app/test/test_ring.c +0 -0
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF |

TEST_RING_ELEM_BURST);

app/test/test_ring.c

Quoted 2 lines
app/test/test_ring.c +0 -2
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of

elements\n",

app/test/test_ring.c test_ring_with_exact_size(void)

Quoted 13 lines
app/test/test_ring.c +2 -8
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) ==

ring_sz,

Quoted 22 lines
app/test/test_ring.c +5 -4
+					exact_sz_r);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
@@ -1061,7 +993,7 @@ test_ring_with_exact_size(void)
 
 	return 0;
 
-test_fail:
+fail:
 	rte_free(src_orig);
 	rte_free(dst_orig);
 	rte_ring_free(std_r);
--

2.17.1

#57 lore raw

v6 cover [dpdk-dev] [PATCH v6 0/7]

In reply to Feifei Wang

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

v3:
1. Adjust the 'check dequeued objects' patch from the last to the first in the series. (Honnappa)
2. Add the new function 'test_ring_mem_cmp to replace 'memset' and print information of enqueue/dequeue elements if validation fails. (Honnappa)
3. Add test to validate the whether the enqueue and dequeue operation is successful for each time. (Honnappa)
4. Expand the scope of application for the macro TEST_RING_VERIF, and replace all ring APIs check with this macro. (Honnappa)

v4:
1. Split the 'memcmp' bug fix patch into two patches, one is memcmp issue patch, the other is to add new function 'test_ring_mem_cmp'. (Honnappa)

v5:
1. Adjust bug fixed patches to the first of the series, to ensure that the back porting will go smooth. (Honnappa)

v6:
1. Add extra parameter to the macro. (Konstantin)

Feifei Wang (7):
test/ring: fix wrong parameter passed to the enqueue APIs test/ring: fix wrong number of enq/deq elements test/ring: fix wrong size used in memcmp test/ring: add check to validate dequeued objects test/ring: validate the return value of enq/deq elements test/ring: add new function to validate dequeue data test/ring: improve the application of macro

 app/test/test_ring.c | 362 ++++++++++++++++++++++---------------------
 app/test/test_ring.h |   6 +-
 2 files changed, 192 insertions(+), 176 deletions(-)
Signature · 1 line
2.17.1
#58 lore raw

PATCH v6 1/7 test/ring: fix wrong parameter passed to the enqueue APIs

When enqueue one element to ring in the performance test, a pointer should be passed to rte_ring_[sp|mp]enqueue APIs, not the pointer to a table of void *pointers.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
app/test/test_ring.h +3 -3
index aa6ae67ca..d4b15af7c 100644
@@ -50,11 +50,11 @@ test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
 	if ((esize) == -1)
 		switch (api_type) {
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
-			return rte_ring_enqueue(r, obj);
+			return rte_ring_enqueue(r, *obj);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_sp_enqueue(r, obj);
+			return rte_ring_sp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
-			return rte_ring_mp_enqueue(r, obj);
+			return rte_ring_mp_enqueue(r, *obj);
 		case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
 			return rte_ring_enqueue_bulk(r, obj, n, NULL);
 		case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
Signature · 1 line
2.17.1
#59 lore raw

PATCH v6 2/7 test/ring: fix wrong number of enq/deq elements

In reply to Feifei Wang

The ring capacity is (RING_SIZE - 1), thus only (RING_SIZE - 1) number of elements can be enqueued into the ring.

Fixes af75078fece3 ("first public release")
---
 app/test/test_ring.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
app/test/test_ring.c +2 -2
index 0ae97d341..04bdc9b69 100644
@@ -811,7 +811,7 @@ test_ring_basic_ex(void)
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_enqueue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
@@ -822,7 +822,7 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
-		for (j = 0; j < RING_SIZE; j++) {
+		for (j = 0; j < RING_SIZE - 1; j++) {
 			test_ring_dequeue(rp, obj, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		}
Signature · 1 line
2.17.1
#60 lore raw

PATCH v6 3/7 test/ring: fix wrong size used in memcmp

In reply to Feifei Wang

When using memcmp function to check data, the third param should be the size of all elements, rather than the number of the elements.

Fixes a9fe152363e2 ("test/ring: add custom element size functional tests")
---
 app/test/test_ring.c | 31 +++++++++++++++++++++----------
 1 file changed, 21 insertions(+), 10 deletions(-)
app/test/test_ring.c +21 -10
index 04bdc9b69..51bae0d48 100644
@@ -444,7 +444,12 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			TEST_RING_VERIFY(memcmp(src, dst, rsz) == 0);
+			if (esize[i] == -1) {
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * sizeof(void *)) == 0);
+			} else
+				TEST_RING_VERIFY(memcmp(src, dst,
+					rsz * esize[i]) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -538,9 +543,11 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -614,9 +621,11 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
@@ -747,9 +756,11 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, cur_dst - dst)) {
-			rte_hexdump(stdout, "src", src, cur_src - src);
-			rte_hexdump(stdout, "dst", dst, cur_dst - dst);
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src,
+					RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst,
+					RTE_PTR_DIFF(cur_dst, dst));
 			printf("data after dequeue is not the same\n");
 			goto fail;
 		}
Signature · 1 line
2.17.1
#61 lore raw

PATCH v6 4/7 test/ring: add check to validate dequeued objects

In reply to Feifei Wang

Add check in test_ring_basic_ex and test_ring_with_exact_size for single element enqueue and dequeue operations to validate the dequeued objects.

---
 app/test/test_ring.c | 135 +++++++++++++++++++++++++++++++------------
 1 file changed, 99 insertions(+), 36 deletions(-)
app/test/test_ring.c +99 -36
index 51bae0d48..c9017793a 100644
@@ -791,15 +791,9 @@ test_ring_basic_ex(void)
 	int ret = -1;
 	unsigned int i, j;
 	struct rte_ring *rp = NULL;
-	void *obj = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 
 	for (i = 0; i < RTE_DIM(esize); i++) {
-		obj = test_ring_calloc(RING_SIZE, esize[i]);
-		if (obj == NULL) {
-			printf("%s: failed to alloc memory\n", __func__);
-			goto fail_test;
-		}
-
 		rp = test_ring_create("test_ring_basic_ex", esize[i], RING_SIZE,
 					SOCKET_ID_ANY,
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -808,6 +802,23 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* alloc dummy object pointers */
+		src = test_ring_calloc(RING_SIZE, esize[i]);
+		if (src == NULL) {
+			printf("%s: failed to alloc src memory\n", __func__);
+			goto fail_test;
+		}
+		test_ring_mem_init(src, RING_SIZE, esize[i]);
+		cur_src = src;
+
+		/* alloc some room for copied objects */
+		dst = test_ring_calloc(RING_SIZE, esize[i]);
+		if (dst == NULL) {
+			printf("%s: failed to alloc dst memory\n", __func__);
+			goto fail_test;
+		}
+		cur_dst = dst;
+
 		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
 			printf("%s: failed to find ring\n", __func__);
 			goto fail_test;
@@ -823,8 +834,9 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, obj, esize[i], 1,
+			test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
 		if (rte_ring_full(rp) != 1) {
@@ -834,8 +846,9 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, obj, esize[i], 1,
+			test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
 		if (rte_ring_empty(rp) != 1) {
@@ -844,52 +857,80 @@ test_ring_basic_ex(void)
 			goto fail_test;
 		}
 
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
+
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
 		 */
+		/* reset memory of dst */
+		memset(dst, 0, RTE_PTR_DIFF(cur_dst, dst));
+
+		/* reset cur_src and cur_dst */
+		cur_src = src;
+		cur_dst = dst;
+
 		/* Covering the ring burst operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
-		ret = test_ring_enqueue(rp, obj, esize[i], 2,
+		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
-		ret = test_ring_dequeue(rp, obj, esize[i], 2,
+		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
 		if (ret != 2) {
 			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
 			goto fail_test;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
+
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto fail_test;
+		}
 
 		rte_ring_free(rp);
-		rte_free(obj);
+		rte_free(src);
+		rte_free(dst);
 		rp = NULL;
-		obj = NULL;
+		src = NULL;
+		dst = NULL;
 	}
 
 	return 0;
 
 fail_test:
 	rte_ring_free(rp);
-	if (obj != NULL)
-		rte_free(obj);
-
+	rte_free(src);
+	rte_free(dst);
 	return -1;
 }
 
@@ -900,8 +941,8 @@ static int
 test_ring_with_exact_size(void)
 {
 	struct rte_ring *std_r = NULL, *exact_sz_r = NULL;
-	void *obj_orig;
-	void *obj;
+	void **src_orig = NULL, **dst_orig = NULL;
+	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	const unsigned int ring_sz = 16;
 	unsigned int i, j;
 	int ret = -1;
@@ -911,14 +952,6 @@ test_ring_with_exact_size(void)
 				TEST_RING_IGNORE_API_TYPE,
 				esize[i]);
 
-		/* alloc object pointers. Allocate one extra object
-		 * and create an unaligned address.
-		 */
-		obj_orig = test_ring_calloc(17, esize[i]);
-		if (obj_orig == NULL)
-			goto test_fail;
-		obj = ((char *)obj_orig) + 1;
-
 		std_r = test_ring_create("std", esize[i], ring_sz,
 					rte_socket_id(),
 					RING_F_SP_ENQ | RING_F_SC_DEQ);
@@ -936,6 +969,22 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
+		/* alloc object pointers. Allocate one extra object
+		 * and create an unaligned address.
+		 */
+		src_orig = test_ring_calloc(17, esize[i]);
+		if (src_orig == NULL)
+			goto test_fail;
+		test_ring_mem_init(src_orig, 17, esize[i]);
+		src = (void **)((uintptr_t)src_orig + 1);
+		cur_src = src;
+
+		dst_orig = test_ring_calloc(17, esize[i]);
+		if (dst_orig == NULL)
+			goto test_fail;
+		dst = (void **)((uintptr_t)dst_orig + 1);
+		cur_dst = dst;
+
 		/*
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
@@ -952,33 +1001,36 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, obj, esize[i], 1,
+			test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
-		ret = test_ring_enqueue(std_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret != -ENOBUFS) {
 			printf("%s: error, unexpected successful enqueue\n",
 				__func__);
 			goto test_fail;
 		}
-		ret = test_ring_enqueue(exact_sz_r, obj, esize[i], 1,
+		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
 		if (ret == -ENOBUFS) {
 			printf("%s: error, enqueue failed\n", __func__);
 			goto test_fail;
 		}
+		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
-		ret = test_ring_dequeue(exact_sz_r, obj, esize[i], ring_sz,
+		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
 		if (ret != (int)ring_sz) {
 			printf("%s: error, failed to dequeue expected nb of elements\n",
 				__func__);
 			goto test_fail;
 		}
+		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
 		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
@@ -987,10 +1039,20 @@ test_ring_with_exact_size(void)
 			goto test_fail;
 		}
 
-		rte_free(obj_orig);
+		/* check data */
+		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
+			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
+			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
+			printf("data after dequeue is not the same\n");
+			goto test_fail;
+		}
+
+		rte_free(src_orig);
+		rte_free(dst_orig);
 		rte_ring_free(std_r);
 		rte_ring_free(exact_sz_r);
-		obj_orig = NULL;
+		src_orig = NULL;
+		dst_orig = NULL;
 		std_r = NULL;
 		exact_sz_r = NULL;
 	}
@@ -998,7 +1060,8 @@ test_ring_with_exact_size(void)
 	return 0;
 
 test_fail:
-	rte_free(obj_orig);
+	rte_free(src_orig);
+	rte_free(dst_orig);
 	rte_ring_free(std_r);
 	rte_ring_free(exact_sz_r);
 	return -1;
Signature · 1 line
2.17.1
#62 lore raw

PATCH v6 5/7 test/ring: validate the return value of enq/deq elements

In reply to Feifei Wang

Validate the return value of single element enqueue/dequeue operation in the test.

---
 app/test/test_ring.c | 26 ++++++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)
app/test/test_ring.c +22 -4
index c9017793a..da57032c7 100644
@@ -834,8 +834,13 @@ test_ring_basic_ex(void)
 			rte_ring_free_count(rp));
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_enqueue(rp, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_enqueue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
@@ -846,8 +851,13 @@ test_ring_basic_ex(void)
 		}
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
-			test_ring_dequeue(rp, cur_dst, esize[i], 1,
+			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: rte_ring_dequeue fails\n",
+					__func__);
+				goto fail_test;
+			}
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
@@ -1001,10 +1011,18 @@ test_ring_with_exact_size(void)
 		 * than the standard ring. (16 vs 15 elements)
 		 */
 		for (j = 0; j < ring_sz - 1; j++) {
-			test_ring_enqueue(std_r, cur_src, esize[i], 1,
+			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
+			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
+			if (ret != 0) {
+				printf("%s: error, enqueue failed\n", __func__);
+				goto test_fail;
+			}
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
Signature · 1 line
2.17.1
#63 lore raw

PATCH v6 6/7 test/ring: add new function to validate dequeue data

In reply to Feifei Wang

Do code clean up by moving repeated code inside 'test_ring_mem_cmp' function to validate data and print information of enqueue/dequeue elements if validation fails.

---
 app/test/test_ring.c | 70 +++++++++++++++++---------------------------
 1 file changed, 27 insertions(+), 43 deletions(-)
app/test/test_ring.c +27 -43
index da57032c7..fb46614f8 100644
@@ -258,6 +258,21 @@ test_ring_mem_init(void *obj, unsigned int count, int esize)
 			((uint32_t *)obj)[i] = i;
 }
 
+static int
+test_ring_mem_cmp(void *src, void *dst, unsigned int size)
+{
+	int ret;
+
+	ret = memcmp(src, dst, size);
+	if (ret) {
+		rte_hexdump(stdout, "src", src, size);
+		rte_hexdump(stdout, "dst", dst, size);
+		printf("data after dequeue is not the same\n");
+	}
+
+	return ret;
+}
+
 static void
 test_ring_print_test_string(const char *istr, unsigned int api_type, int esize)
 {
@@ -383,7 +398,7 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 	struct rte_ring *r;
 	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
 	int ret;
-	unsigned int i, j;
+	unsigned int i, j, temp_sz;
 	int rand;
 	const unsigned int rsz = RING_SIZE - 1;
 
@@ -444,12 +459,11 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 			TEST_RING_VERIFY(rte_ring_empty(r));
 
 			/* check data */
-			if (esize[i] == -1) {
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * sizeof(void *)) == 0);
-			} else
-				TEST_RING_VERIFY(memcmp(src, dst,
-					rsz * esize[i]) == 0);
+			temp_sz = rsz * sizeof(void *);
+			if (esize[i] != -1)
+				temp_sz = rsz * esize[i];
+			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+						temp_sz) == 0);
 		}
 
 		/* Free memory before test completed */
@@ -543,14 +557,8 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -621,14 +629,8 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -756,14 +758,8 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			goto fail;
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src,
-					RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst,
-					RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail;
-		}
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -868,12 +864,8 @@ test_ring_basic_ex(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -920,12 +912,8 @@ test_ring_basic_ex(void)
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto fail_test;
-		}
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -1058,12 +1046,8 @@ test_ring_with_exact_size(void)
 		}
 
 		/* check data */
-		if (memcmp(src, dst, RTE_PTR_DIFF(cur_dst, dst))) {
-			rte_hexdump(stdout, "src", src, RTE_PTR_DIFF(cur_src, src));
-			rte_hexdump(stdout, "dst", dst, RTE_PTR_DIFF(cur_dst, dst));
-			printf("data after dequeue is not the same\n");
+		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
 			goto test_fail;
-		}
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
Signature · 1 line
2.17.1
#64 lore raw

PATCH v6 7/7 test/ring: improve the application of macro

In reply to Feifei Wang

Add more parameters into the macro TEST_RING_VERIFY and expand the scope of application for it. Then replace all ring APIs check with TEST_RING_VERIFY to facilitate debugging.

Furthermore, correct a spelling mistakes of the macro TEST_RING_FULL_EMTPY_ITER.

---
 app/test/test_ring.c | 240 ++++++++++++++++---------------------------
 1 file changed, 90 insertions(+), 150 deletions(-)
app/test/test_ring.c +90 -150
index fb46614f8..a62cb263b 100644
@@ -46,15 +46,25 @@
 #define RING_SIZE 4096
 #define MAX_BULK 32
 
-#define	TEST_RING_VERIFY(exp)						\
+/*
+ * Validate the return value of test cases and print details of the
+ * ring if validation fails
+ *
+ * @param exp
+ *   Expression to validate return value.
+ * @param r
+ *   A pointer to the ring structure.
+ */
+#define TEST_RING_VERIFY(exp, r, errst) do {				\
 	if (!(exp)) {							\
 		printf("error at %s:%d\tcondition " #exp " failed\n",	\
 		    __func__, __LINE__);				\
-		rte_ring_dump(stdout, r);				\
-		return -1;						\
-	}
+		rte_ring_dump(stdout, (r));				\
+		errst;							\
+	}								\
+} while (0)
 
-#define	TEST_RING_FULL_EMTPY_ITER	8
+#define TEST_RING_FULL_EMPTY_ITER	8
 
 static const int esize[] = {-1, 4, 8, 16, 20};
 
@@ -360,13 +370,10 @@ test_ring_negative_tests(void)
 			goto test_fail;
 		}
 
-		if (rte_ring_lookup("test_ring_negative") != rp)
-			goto test_fail;
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_negative") == rp,
+					rp, goto test_fail);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("test_ring_nagative ring is not empty but it should be\n");
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp, goto test_fail);
 
 		/* Tests if it would always fail to create ring with an used
 		 * ring name.
@@ -426,44 +433,45 @@ test_ring_burst_bulk_tests1(unsigned int test_idx)
 
 		printf("Random full/empty test\n");
 
-		for (j = 0; j != TEST_RING_FULL_EMTPY_ITER; j++) {
+		for (j = 0; j != TEST_RING_FULL_EMPTY_ITER; j++) {
 			/* random shift in the ring */
 			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
 			printf("%s: iteration %u, random shift: %u;\n",
 			    __func__, i, rand);
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r, goto fail);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
 							test_idx);
-			TEST_RING_VERIFY(ret == rand);
+			TEST_RING_VERIFY(ret == rand, r, goto fail);
 
 			/* fill the ring */
 			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret != 0);
+			TEST_RING_VERIFY(ret != 0, r, goto fail);
 
-			TEST_RING_VERIFY(rte_ring_free_count(r) == 0);
-			TEST_RING_VERIFY(rsz == rte_ring_count(r));
-			TEST_RING_VERIFY(rte_ring_full(r));
-			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
+			TEST_RING_VERIFY(rte_ring_free_count(r) == 0, r, goto fail);
+			TEST_RING_VERIFY(rsz == rte_ring_count(r), r, goto fail);
+			TEST_RING_VERIFY(rte_ring_full(r), r, goto fail);
+			TEST_RING_VERIFY(rte_ring_empty(r) == 0, r, goto fail);
 
 			/* empty the ring */
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], rsz,
 							test_idx);
-			TEST_RING_VERIFY(ret == (int)rsz);
-			TEST_RING_VERIFY(rsz == rte_ring_free_count(r));
-			TEST_RING_VERIFY(rte_ring_count(r) == 0);
-			TEST_RING_VERIFY(rte_ring_full(r) == 0);
-			TEST_RING_VERIFY(rte_ring_empty(r));
+			TEST_RING_VERIFY(ret == (int)rsz, r, goto fail);
+
+			TEST_RING_VERIFY(rsz == rte_ring_free_count(r), r, goto fail);
+			TEST_RING_VERIFY(rte_ring_count(r) == 0, r, goto fail);
+			TEST_RING_VERIFY(rte_ring_full(r) == 0, r, goto fail);
+			TEST_RING_VERIFY(rte_ring_empty(r), r, goto fail);
 
 			/* check data */
 			temp_sz = rsz * sizeof(void *);
 			if (esize[i] != -1)
 				temp_sz = rsz * esize[i];
 			TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
-						temp_sz) == 0);
+						temp_sz) == 0, r, goto fail);
 		}
 
 		/* Free memory before test completed */
@@ -520,45 +528,40 @@ test_ring_burst_bulk_tests2(unsigned int test_idx)
 
 		printf("enqueue 1 obj\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r, goto fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		printf("enqueue 2 objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r, goto fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("enqueue MAX_BULK objs\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
 
 		printf("dequeue 1 obj\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
-		if (ret != 1)
-			goto fail;
+		TEST_RING_VERIFY(ret == 1, r, goto fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 
 		printf("dequeue 2 objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r, goto fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		printf("dequeue MAX_BULK objs\n");
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != MAX_BULK)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					r, goto fail);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -615,22 +618,21 @@ test_ring_burst_bulk_tests3(unsigned int test_idx)
 		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					r, goto fail);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -690,16 +692,14 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
 			ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i],
 								MAX_BULK);
 		}
 
 		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r, goto fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		printf("Enqueue the remaining entries = MAX_BULK - 3\n");
@@ -711,34 +711,29 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 		/* Always one free entry left */
 		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r, goto fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is full\n");
-		if (rte_ring_full(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_full(r) == 1, r, goto fail);
 
 		printf("Test enqueue for a full entry\n");
 		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
 						test_idx);
-		if (ret != 0)
-			goto fail;
+		TEST_RING_VERIFY(ret == 0, r, goto fail);
 
 		printf("Test dequeue without enough objects\n");
 		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
 			ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
 							test_idx);
-			if (ret != MAX_BULK)
-				goto fail;
+			TEST_RING_VERIFY(ret == MAX_BULK, r, goto fail);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i],
 								MAX_BULK);
 		}
 
 		/* Available memory space for the exact MAX_BULK entries */
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
-		if (ret != 2)
-			goto fail;
+		TEST_RING_VERIFY(ret == 2, r, goto fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Bulk APIs enqueue exact number of elements */
@@ -748,18 +743,17 @@ test_ring_burst_bulk_tests4(unsigned int test_idx)
 			num_elems = MAX_BULK;
 		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
 						test_idx);
-		if (ret != MAX_BULK - 3)
-			goto fail;
+		TEST_RING_VERIFY(ret == MAX_BULK - 3, r, goto fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
 
 		printf("Test if ring is empty\n");
 		/* Check if ring is empty */
-		if (rte_ring_empty(r) != 1)
-			goto fail;
+		TEST_RING_VERIFY(rte_ring_empty(r) == 1, r, goto fail);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					r, goto fail);
 
 		/* Free memory before test completed */
 		rte_ring_free(r);
@@ -815,16 +809,10 @@ test_ring_basic_ex(void)
 		}
 		cur_dst = dst;
 
-		if (rte_ring_lookup("test_ring_basic_ex") != rp) {
-			printf("%s: failed to find ring\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_lookup("test_ring_basic_ex") == rp,
+					rp, goto fail_test);
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp, goto fail_test);
 
 		printf("%u ring entries are now free\n",
 			rte_ring_free_count(rp));
@@ -832,40 +820,25 @@ test_ring_basic_ex(void)
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_enqueue(rp, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_enqueue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp, goto fail_test);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 
-		if (rte_ring_full(rp) != 1) {
-			printf("%s: ring is not full but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_full(rp) == 1, rp, goto fail_test);
 
 		for (j = 0; j < RING_SIZE - 1; j++) {
 			ret = test_ring_dequeue(rp, cur_dst, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: rte_ring_dequeue fails\n",
-					__func__);
-				goto fail_test;
-			}
+			TEST_RING_VERIFY(ret == 0, rp, goto fail_test);
 			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
 		}
 
-		if (rte_ring_empty(rp) != 1) {
-			printf("%s: ring is not empty but it should be\n",
-				__func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(rte_ring_empty(rp) == 1, rp, goto fail_test);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					rp, goto fail_test);
 
 		/* Following tests use the configured flags to decide
 		 * SP/SC or MP/MC.
@@ -880,40 +853,29 @@ test_ring_basic_ex(void)
 		/* Covering the ring burst operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp, goto fail_test);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_burst fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp, goto fail_test);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* Covering the ring bulk operation */
 		ret = test_ring_enqueue(rp, cur_src, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_enqueue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp, goto fail_test);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
 
 		ret = test_ring_dequeue(rp, cur_dst, esize[i], 2,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK);
-		if (ret != 2) {
-			printf("%s: rte_ring_dequeue_bulk fails\n", __func__);
-			goto fail_test;
-		}
+		TEST_RING_VERIFY(ret == 2, rp, goto fail_test);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto fail_test;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					rp, goto fail_test);
 
 		rte_ring_free(rp);
 		rte_free(src);
@@ -987,13 +949,10 @@ test_ring_with_exact_size(void)
 		 * Check that the exact size ring is bigger than the
 		 * standard ring
 		 */
-		if (rte_ring_get_size(std_r) >= rte_ring_get_size(exact_sz_r)) {
-			printf("%s: error, std ring (size: %u) is not smaller than exact size one (size %u)\n",
-					__func__,
-					rte_ring_get_size(std_r),
-					rte_ring_get_size(exact_sz_r));
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_size(std_r) <=
+				rte_ring_get_size(exact_sz_r),
+				std_r, goto test_fail);
+
 		/*
 		 * check that the exact_sz_ring can hold one more element
 		 * than the standard ring. (16 vs 15 elements)
@@ -1001,53 +960,34 @@ test_ring_with_exact_size(void)
 		for (j = 0; j < ring_sz - 1; j++) {
 			ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, std_r, goto test_fail);
 			ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-			if (ret != 0) {
-				printf("%s: error, enqueue failed\n", __func__);
-				goto test_fail;
-			}
+			TEST_RING_VERIFY(ret == 0, exact_sz_r, goto test_fail);
 			cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 		}
 		ret = test_ring_enqueue(std_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret != -ENOBUFS) {
-			printf("%s: error, unexpected successful enqueue\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == -ENOBUFS, std_r, goto test_fail);
 		ret = test_ring_enqueue(exact_sz_r, cur_src, esize[i], 1,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE);
-		if (ret == -ENOBUFS) {
-			printf("%s: error, enqueue failed\n", __func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret != -ENOBUFS, exact_sz_r, goto test_fail);
 		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
 
 		/* check that dequeue returns the expected number of elements */
 		ret = test_ring_dequeue(exact_sz_r, cur_dst, esize[i], ring_sz,
 				TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST);
-		if (ret != (int)ring_sz) {
-			printf("%s: error, failed to dequeue expected nb of elements\n",
-				__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(ret == (int)ring_sz, exact_sz_r, goto test_fail);
 		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], ring_sz);
 
 		/* check that the capacity function returns expected value */
-		if (rte_ring_get_capacity(exact_sz_r) != ring_sz) {
-			printf("%s: error, incorrect ring capacity reported\n",
-					__func__);
-			goto test_fail;
-		}
+		TEST_RING_VERIFY(rte_ring_get_capacity(exact_sz_r) == ring_sz,
+					exact_sz_r, goto test_fail);
 
 		/* check data */
-		if (test_ring_mem_cmp(src, dst, RTE_PTR_DIFF(cur_dst, dst)))
-			goto test_fail;
+		TEST_RING_VERIFY(test_ring_mem_cmp(src, dst,
+					RTE_PTR_DIFF(cur_dst, dst)) == 0,
+					exact_sz_r, goto test_fail);
 
 		rte_free(src_orig);
 		rte_free(dst_orig);
Signature · 1 line
2.17.1
#65 lore raw

Re: [dpdk-dev] [PATCH v6 0/7]

In reply to Feifei Wang
Quoted 46 lines

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

v2:
1. add check to validate the dequeued objects in test_ring.c and fix some bugs of it. (David/Honnappa)
2. remove the patch to change the description for the param of rte_ring_[sp/mp]_enqueue APIs. (David/Konstantin/Honnappa)

v3:
1. Adjust the 'check dequeued objects' patch from the last to the first in the series. (Honnappa)
2. Add the new function 'test_ring_mem_cmp to replace 'memset' and print information of enqueue/dequeue elements if validation fails. (Honnappa)
3. Add test to validate the whether the enqueue and dequeue operation is successful for each time. (Honnappa)
4. Expand the scope of application for the macro TEST_RING_VERIF, and replace all ring APIs check with this macro. (Honnappa)

v4:
1. Split the 'memcmp' bug fix patch into two patches, one is memcmp issue patch, the other is to add new function 'test_ring_mem_cmp'. (Honnappa)

v5:
1. Adjust bug fixed patches to the first of the series, to ensure that the back porting will go smooth. (Honnappa)

v6:
1. Add extra parameter to the macro. (Konstantin)

Feifei Wang (7):
test/ring: fix wrong parameter passed to the enqueue APIs test/ring: fix wrong number of enq/deq elements test/ring: fix wrong size used in memcmp test/ring: add check to validate dequeued objects test/ring: validate the return value of enq/deq elements test/ring: add new function to validate dequeue data test/ring: improve the application of macro

Quoted 3 lines
 app/test/test_ring.c | 362 ++++++++++++++++++++++---------------------
 app/test/test_ring.h |   6 +-
 2 files changed, 192 insertions(+), 176 deletions(-)

Series acked-by: Konstantin Ananyev <[email protected]>

Quoted 2 lines

--
2.17.1

#66 lore raw

Re: [dpdk-dev] [PATCH v6 0/7]

In reply to Feifei Wang
Quoted 9 lines · Feifei Wang

Several bugs in ring unit tests were identified and fixed.

Added data validation on objects after enqueue/dequeue operations for data integration check.

Unit tests were enhanced by checking return value of enqueue/dequeue operations and validating data integrity of objects.

Series applied, thanks for the effort on debugging and improving this ut.

Signature · 1 line
David Marchand