DPDK patches and discussions
 help / color / mirror / Atom feed
From: Honnappa Nagarahalli <Honnappa.Nagarahalli@arm.com>
To: Konstantin Ananyev <konstantin.ananyev@intel.com>,
	"dev@dpdk.org" <dev@dpdk.org>
Cc: "aconole@redhat.com" <aconole@redhat.com>, nd <nd@arm.com>,
	Honnappa Nagarahalli <Honnappa.Nagarahalli@arm.com>,
	"thomas@monjalon.net" <thomas@monjalon.net>,
	David Marchand <david.marchand@redhat.com>, nd <nd@arm.com>
Subject: Re: [dpdk-dev] [PATCH] test/ring: code rework to reduce compilation time
Date: Thu, 2 Jul 2020 20:47:09 +0000
Message-ID: <DB6PR0802MB22169B129DD6206B8FAC9223986D0@DB6PR0802MB2216.eurprd08.prod.outlook.com> (raw)
In-Reply-To: <20200429175714.31141-1-konstantin.ananyev@intel.com>

<snip>

> 
> Rework test code to reduce code complexity for the compiler and bring down
> compilation time and memory consumption.
> 
> Signed-off-by: Konstantin Ananyev <konstantin.ananyev@intel.com>

Thomas has a nit [1]. Otherwise,

Acked-by: Honnappa Nagarahalli <honnappa.nagarahalli@arm.com>

[1] http://mails.dpdk.org/archives/dev/2020-May/166325.html

> ---
>  app/test/test_ring.c | 373 +++++++++++++++++++++++++++++--------------
>  1 file changed, 249 insertions(+), 124 deletions(-)
> 
> diff --git a/app/test/test_ring.c b/app/test/test_ring.c index
> e21557cd9..0ae97d341 100644
> --- a/app/test/test_ring.c
> +++ b/app/test/test_ring.c
> @@ -58,6 +58,181 @@
> 
>  static const int esize[] = {-1, 4, 8, 16, 20};
> 
> +static const struct {
> +	const char *desc;
> +	uint32_t api_type;
> +	uint32_t create_flags;
> +	struct {
> +		unsigned int (*flegacy)(struct rte_ring *r,
> +			void * const *obj_table, unsigned int n,
> +			unsigned int *free_space);
> +		unsigned int (*felem)(struct rte_ring *r, const void *obj_table,
> +			unsigned int esize, unsigned int n,
> +			unsigned int *free_space);
> +	} enq;
> +	struct {
> +		unsigned int (*flegacy)(struct rte_ring *r,
> +			void **obj_table, unsigned int n,
> +			unsigned int *available);
> +		unsigned int (*felem)(struct rte_ring *r, void *obj_table,
> +			unsigned int esize, unsigned int n,
> +			unsigned int *available);
> +	} deq;
> +} test_enqdeq_impl[] = {
> +	{
> +		.desc = "MP/MC sync mode",
> +		.api_type = TEST_RING_ELEM_BULK |
> TEST_RING_THREAD_DEF,
> +		.create_flags = 0,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_bulk,
> +			.felem = rte_ring_enqueue_bulk_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_bulk,
> +			.felem = rte_ring_dequeue_bulk_elem,
> +		},
> +	},
> +	{
> +		.desc = "SP/SC sync mode",
> +		.api_type = TEST_RING_ELEM_BULK |
> TEST_RING_THREAD_SPSC,
> +		.create_flags = RING_F_SP_ENQ | RING_F_SC_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_sp_enqueue_bulk,
> +			.felem = rte_ring_sp_enqueue_bulk_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_sc_dequeue_bulk,
> +			.felem = rte_ring_sc_dequeue_bulk_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP/MC sync mode",
> +		.api_type = TEST_RING_ELEM_BULK |
> TEST_RING_THREAD_MPMC,
> +		.create_flags = 0,
> +		.enq = {
> +			.flegacy = rte_ring_mp_enqueue_bulk,
> +			.felem = rte_ring_mp_enqueue_bulk_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_mc_dequeue_bulk,
> +			.felem = rte_ring_mc_dequeue_bulk_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP_RTS/MC_RTS sync mode",
> +		.api_type = TEST_RING_ELEM_BULK |
> TEST_RING_THREAD_DEF,
> +		.create_flags = RING_F_MP_RTS_ENQ | RING_F_MC_RTS_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_bulk,
> +			.felem = rte_ring_enqueue_bulk_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_bulk,
> +			.felem = rte_ring_dequeue_bulk_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP_HTS/MC_HTS sync mode",
> +		.api_type = TEST_RING_ELEM_BULK |
> TEST_RING_THREAD_DEF,
> +		.create_flags = RING_F_MP_HTS_ENQ | RING_F_MC_HTS_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_bulk,
> +			.felem = rte_ring_enqueue_bulk_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_bulk,
> +			.felem = rte_ring_dequeue_bulk_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP/MC sync mode",
> +		.api_type = TEST_RING_ELEM_BURST |
> TEST_RING_THREAD_DEF,
> +		.create_flags = 0,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_burst,
> +			.felem = rte_ring_enqueue_burst_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_burst,
> +			.felem = rte_ring_dequeue_burst_elem,
> +		},
> +	},
> +	{
> +		.desc = "SP/SC sync mode",
> +		.api_type = TEST_RING_ELEM_BURST |
> TEST_RING_THREAD_SPSC,
> +		.create_flags = RING_F_SP_ENQ | RING_F_SC_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_sp_enqueue_burst,
> +			.felem = rte_ring_sp_enqueue_burst_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_sc_dequeue_burst,
> +			.felem = rte_ring_sc_dequeue_burst_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP/MC sync mode",
> +		.api_type = TEST_RING_ELEM_BURST |
> TEST_RING_THREAD_MPMC,
> +		.create_flags = 0,
> +		.enq = {
> +			.flegacy = rte_ring_mp_enqueue_burst,
> +			.felem = rte_ring_mp_enqueue_burst_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_mc_dequeue_burst,
> +			.felem = rte_ring_mc_dequeue_burst_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP_RTS/MC_RTS sync mode",
> +		.api_type = TEST_RING_ELEM_BURST |
> TEST_RING_THREAD_DEF,
> +		.create_flags = RING_F_MP_RTS_ENQ | RING_F_MC_RTS_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_burst,
> +			.felem = rte_ring_enqueue_burst_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_burst,
> +			.felem = rte_ring_dequeue_burst_elem,
> +		},
> +	},
> +	{
> +		.desc = "MP_HTS/MC_HTS sync mode",
> +		.api_type = TEST_RING_ELEM_BURST |
> TEST_RING_THREAD_DEF,
> +		.create_flags = RING_F_MP_HTS_ENQ | RING_F_MC_HTS_DEQ,
> +		.enq = {
> +			.flegacy = rte_ring_enqueue_burst,
> +			.felem = rte_ring_enqueue_burst_elem,
> +		},
> +		.deq = {
> +			.flegacy = rte_ring_dequeue_burst,
> +			.felem = rte_ring_dequeue_burst_elem,
> +		},
> +	},
> +};
> +
> +static unsigned int
> +test_ring_enq_impl(struct rte_ring *r, void **obj, int esize, unsigned int n,
> +	unsigned int test_idx)
> +{
> +	if (esize == -1)
> +		return test_enqdeq_impl[test_idx].enq.flegacy(r, obj, n, NULL);
> +	else
> +		return test_enqdeq_impl[test_idx].enq.felem(r, obj, esize, n,
> +			NULL);
> +}
> +
> +static unsigned int
> +test_ring_deq_impl(struct rte_ring *r, void **obj, int esize, unsigned int n,
> +	unsigned int test_idx)
> +{
> +	if (esize == -1)
> +		return test_enqdeq_impl[test_idx].deq.flegacy(r, obj, n, NULL);
> +	else
> +		return test_enqdeq_impl[test_idx].deq.felem(r, obj, esize, n,
> +			NULL);
> +}
> +
>  static void**
>  test_ring_inc_ptr(void **obj, int esize, unsigned int n)  { @@ -203,8 +378,7
> @@ test_ring_negative_tests(void)
>   * Random number of elements are enqueued and dequeued.
>   */
>  static int
> -test_ring_burst_bulk_tests1(unsigned int api_type, unsigned int create_flags,
> -	const char *tname)
> +test_ring_burst_bulk_tests1(unsigned int test_idx)
>  {
>  	struct rte_ring *r;
>  	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
> @@ -214,11 +388,13 @@ test_ring_burst_bulk_tests1(unsigned int api_type,
> unsigned int create_flags,
>  	const unsigned int rsz = RING_SIZE - 1;
> 
>  	for (i = 0; i < RTE_DIM(esize); i++) {
> -		test_ring_print_test_string(tname, api_type, esize[i]);
> +		test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> +			test_enqdeq_impl[test_idx].api_type, esize[i]);
> 
>  		/* Create the ring */
>  		r = test_ring_create("test_ring_burst_bulk_tests", esize[i],
> -					RING_SIZE, SOCKET_ID_ANY,
> create_flags);
> +				RING_SIZE, SOCKET_ID_ANY,
> +				test_enqdeq_impl[test_idx].create_flags);
> 
>  		/* alloc dummy object pointers */
>  		src = test_ring_calloc(RING_SIZE * 2, esize[i]); @@ -240,17
> +416,17 @@ test_ring_burst_bulk_tests1(unsigned int api_type, unsigned int
> create_flags,
>  			rand = RTE_MAX(rte_rand() % RING_SIZE, 1UL);
>  			printf("%s: iteration %u, random shift: %u;\n",
>  			    __func__, i, rand);
> -			ret = test_ring_enqueue(r, cur_src, esize[i], rand,
> -							api_type);
> +			ret = test_ring_enq_impl(r, cur_src, esize[i], rand,
> +							test_idx);
>  			TEST_RING_VERIFY(ret != 0);
> 
> -			ret = test_ring_dequeue(r, cur_dst, esize[i], rand,
> -							api_type);
> +			ret = test_ring_deq_impl(r, cur_dst, esize[i], rand,
> +							test_idx);
>  			TEST_RING_VERIFY(ret == rand);
> 
>  			/* fill the ring */
> -			ret = test_ring_enqueue(r, cur_src, esize[i], rsz,
> -							api_type);
> +			ret = test_ring_enq_impl(r, cur_src, esize[i], rsz,
> +							test_idx);
>  			TEST_RING_VERIFY(ret != 0);
> 
>  			TEST_RING_VERIFY(rte_ring_free_count(r) == 0); @@ -
> 259,8 +435,8 @@ test_ring_burst_bulk_tests1(unsigned int api_type,
> unsigned int create_flags,
>  			TEST_RING_VERIFY(rte_ring_empty(r) == 0);
> 
>  			/* empty the ring */
> -			ret = test_ring_dequeue(r, cur_dst, esize[i], rsz,
> -							api_type);
> +			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); @@ -294,8
> +470,7 @@ test_ring_burst_bulk_tests1(unsigned int api_type, unsigned int
> create_flags,
>   * dequeued data.
>   */
>  static int
> -test_ring_burst_bulk_tests2(unsigned int api_type, unsigned int create_flags,
> -	const char *tname)
> +test_ring_burst_bulk_tests2(unsigned int test_idx)
>  {
>  	struct rte_ring *r;
>  	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
> @@ -303,11 +478,13 @@ test_ring_burst_bulk_tests2(unsigned int api_type,
> unsigned int create_flags,
>  	unsigned int i;
> 
>  	for (i = 0; i < RTE_DIM(esize); i++) {
> -		test_ring_print_test_string(tname, api_type, esize[i]);
> +		test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> +			test_enqdeq_impl[test_idx].api_type, esize[i]);
> 
>  		/* Create the ring */
>  		r = test_ring_create("test_ring_burst_bulk_tests", esize[i],
> -					RING_SIZE, SOCKET_ID_ANY,
> create_flags);
> +				RING_SIZE, SOCKET_ID_ANY,
> +				test_enqdeq_impl[test_idx].create_flags);
> 
>  		/* alloc dummy object pointers */
>  		src = test_ring_calloc(RING_SIZE * 2, esize[i]); @@ -323,39
> +500,39 @@ test_ring_burst_bulk_tests2(unsigned int api_type, unsigned int
> create_flags,
>  		cur_dst = dst;
> 
>  		printf("enqueue 1 obj\n");
> -		ret = test_ring_enqueue(r, cur_src, esize[i], 1, api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], 1, test_idx);
>  		if (ret != 1)
>  			goto fail;
>  		cur_src = test_ring_inc_ptr(cur_src, esize[i], 1);
> 
>  		printf("enqueue 2 objs\n");
> -		ret = test_ring_enqueue(r, cur_src, esize[i], 2, api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
>  		if (ret != 2)
>  			goto fail;
>  		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2);
> 
>  		printf("enqueue MAX_BULK objs\n");
> -		ret = test_ring_enqueue(r, cur_src, esize[i], MAX_BULK,
> -						api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
> +						test_idx);
>  		if (ret != MAX_BULK)
>  			goto fail;
>  		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK);
> 
>  		printf("dequeue 1 obj\n");
> -		ret = test_ring_dequeue(r, cur_dst, esize[i], 1, api_type);
> +		ret = test_ring_deq_impl(r, cur_dst, esize[i], 1, test_idx);
>  		if (ret != 1)
>  			goto fail;
>  		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 1);
> 
>  		printf("dequeue 2 objs\n");
> -		ret = test_ring_dequeue(r, cur_dst, esize[i], 2, api_type);
> +		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
>  		if (ret != 2)
>  			goto fail;
>  		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2);
> 
>  		printf("dequeue MAX_BULK objs\n");
> -		ret = test_ring_dequeue(r, cur_dst, esize[i], MAX_BULK,
> -						api_type);
> +		ret = test_ring_deq_impl(r, cur_dst, esize[i], MAX_BULK,
> +						test_idx);
>  		if (ret != MAX_BULK)
>  			goto fail;
>  		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK); @@
> -390,8 +567,7 @@ test_ring_burst_bulk_tests2(unsigned int api_type,
> unsigned int create_flags,
>   * Enqueue and dequeue to cover the entire ring length.
>   */
>  static int
> -test_ring_burst_bulk_tests3(unsigned int api_type, unsigned int create_flags,
> -	const char *tname)
> +test_ring_burst_bulk_tests3(unsigned int test_idx)
>  {
>  	struct rte_ring *r;
>  	void **src = NULL, **cur_src = NULL, **dst = NULL, **cur_dst = NULL;
> @@ -399,11 +575,13 @@ test_ring_burst_bulk_tests3(unsigned int api_type,
> unsigned int create_flags,
>  	unsigned int i, j;
> 
>  	for (i = 0; i < RTE_DIM(esize); i++) {
> -		test_ring_print_test_string(tname, api_type, esize[i]);
> +		test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> +			test_enqdeq_impl[test_idx].api_type, esize[i]);
> 
>  		/* Create the ring */
>  		r = test_ring_create("test_ring_burst_bulk_tests", esize[i],
> -					RING_SIZE, SOCKET_ID_ANY,
> create_flags);
> +				RING_SIZE, SOCKET_ID_ANY,
> +				test_enqdeq_impl[test_idx].create_flags);
> 
>  		/* alloc dummy object pointers */
>  		src = test_ring_calloc(RING_SIZE * 2, esize[i]); @@ -420,15
> +598,15 @@ test_ring_burst_bulk_tests3(unsigned int api_type, unsigned int
> create_flags,
> 
>  		printf("fill and empty the ring\n");
>  		for (j = 0; j < RING_SIZE / MAX_BULK; j++) {
> -			ret = test_ring_enqueue(r, cur_src, esize[i], MAX_BULK,
> -							api_type);
> +			ret = test_ring_enq_impl(r, cur_src, esize[i],
> MAX_BULK,
> +							test_idx);
>  			if (ret != MAX_BULK)
>  				goto fail;
>  			cur_src = test_ring_inc_ptr(cur_src, esize[i],
>  								MAX_BULK);
> 
> -			ret = test_ring_dequeue(r, cur_dst, esize[i],
> MAX_BULK,
> -							api_type);
> +			ret = test_ring_deq_impl(r, cur_dst, esize[i],
> MAX_BULK,
> +							test_idx);
>  			if (ret != MAX_BULK)
>  				goto fail;
>  			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], @@ -
> 465,21 +643,24 @@ test_ring_burst_bulk_tests3(unsigned int api_type,
> unsigned int create_flags,
>   * Enqueue till the ring is full and dequeue till the ring becomes empty.
>   */
>  static int
> -test_ring_burst_bulk_tests4(unsigned int api_type, unsigned int create_flags,
> -	const char *tname)
> +test_ring_burst_bulk_tests4(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 num_elems;
> +	unsigned int api_type, num_elems;
> +
> +	api_type = test_enqdeq_impl[test_idx].api_type;
> 
>  	for (i = 0; i < RTE_DIM(esize); i++) {
> -		test_ring_print_test_string(tname, api_type, esize[i]);
> +		test_ring_print_test_string(test_enqdeq_impl[test_idx].desc,
> +			test_enqdeq_impl[test_idx].api_type, esize[i]);
> 
>  		/* Create the ring */
>  		r = test_ring_create("test_ring_burst_bulk_tests", esize[i],
> -					RING_SIZE, SOCKET_ID_ANY,
> create_flags);
> +				RING_SIZE, SOCKET_ID_ANY,
> +				test_enqdeq_impl[test_idx].create_flags);
> 
>  		/* alloc dummy object pointers */
>  		src = test_ring_calloc(RING_SIZE * 2, esize[i]); @@ -496,8
> +677,8 @@ test_ring_burst_bulk_tests4(unsigned int api_type, unsigned int
> create_flags,
> 
>  		printf("Test enqueue without enough memory space\n");
>  		for (j = 0; j < (RING_SIZE/MAX_BULK - 1); j++) {
> -			ret = test_ring_enqueue(r, cur_src, esize[i], MAX_BULK,
> -							api_type);
> +			ret = test_ring_enq_impl(r, cur_src, esize[i],
> MAX_BULK,
> +							test_idx);
>  			if (ret != MAX_BULK)
>  				goto fail;
>  			cur_src = test_ring_inc_ptr(cur_src, esize[i], @@ -
> 505,7 +686,7 @@ test_ring_burst_bulk_tests4(unsigned int api_type,
> unsigned int create_flags,
>  		}
> 
>  		printf("Enqueue 2 objects, free entries = MAX_BULK - 2\n");
> -		ret = test_ring_enqueue(r, cur_src, esize[i], 2, api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], 2, test_idx);
>  		if (ret != 2)
>  			goto fail;
>  		cur_src = test_ring_inc_ptr(cur_src, esize[i], 2); @@ -517,8
> +698,8 @@ test_ring_burst_bulk_tests4(unsigned int api_type, unsigned int
> create_flags,
>  		else
>  			num_elems = MAX_BULK;
>  		/* Always one free entry left */
> -		ret = test_ring_enqueue(r, cur_src, esize[i], num_elems,
> -						api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], num_elems,
> +						test_idx);
>  		if (ret != MAX_BULK - 3)
>  			goto fail;
>  		cur_src = test_ring_inc_ptr(cur_src, esize[i], MAX_BULK - 3);
> @@ -528,15 +709,15 @@ test_ring_burst_bulk_tests4(unsigned int api_type,
> unsigned int create_flags,
>  			goto fail;
> 
>  		printf("Test enqueue for a full entry\n");
> -		ret = test_ring_enqueue(r, cur_src, esize[i], MAX_BULK,
> -						api_type);
> +		ret = test_ring_enq_impl(r, cur_src, esize[i], MAX_BULK,
> +						test_idx);
>  		if (ret != 0)
>  			goto fail;
> 
>  		printf("Test dequeue without enough objects\n");
>  		for (j = 0; j < RING_SIZE / MAX_BULK - 1; j++) {
> -			ret = test_ring_dequeue(r, cur_dst, esize[i],
> MAX_BULK,
> -							api_type);
> +			ret = test_ring_deq_impl(r, cur_dst, esize[i],
> MAX_BULK,
> +							test_idx);
>  			if (ret != MAX_BULK)
>  				goto fail;
>  			cur_dst = test_ring_inc_ptr(cur_dst, esize[i], @@ -
> 544,7 +725,7 @@ test_ring_burst_bulk_tests4(unsigned int api_type,
> unsigned int create_flags,
>  		}
> 
>  		/* Available memory space for the exact MAX_BULK entries */
> -		ret = test_ring_dequeue(r, cur_dst, esize[i], 2, api_type);
> +		ret = test_ring_deq_impl(r, cur_dst, esize[i], 2, test_idx);
>  		if (ret != 2)
>  			goto fail;
>  		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], 2); @@ -554,8
> +735,8 @@ test_ring_burst_bulk_tests4(unsigned int api_type, unsigned int
> create_flags,
>  			num_elems = MAX_BULK - 3;
>  		else
>  			num_elems = MAX_BULK;
> -		ret = test_ring_dequeue(r, cur_dst, esize[i], num_elems,
> -						api_type);
> +		ret = test_ring_deq_impl(r, cur_dst, esize[i], num_elems,
> +						test_idx);
>  		if (ret != MAX_BULK - 3)
>  			goto fail;
>  		cur_dst = test_ring_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);
> @@ -816,22 +997,7 @@ static int
>  test_ring(void)
>  {
>  	int32_t rc;
> -	unsigned int i, j;
> -	const char *tname;
> -
> -	static const struct {
> -		uint32_t create_flags;
> -		const char *name;
> -	} test_sync_modes[] = {
> -		{
> -			RING_F_MP_RTS_ENQ | RING_F_MC_RTS_DEQ,
> -			"Test MT_RTS ring",
> -		},
> -		{
> -			RING_F_MP_HTS_ENQ | RING_F_MC_HTS_DEQ,
> -			"Test MT_HTS ring",
> -		},
> -	};
> +	unsigned int i;
> 
>  	/* Negative test cases */
>  	if (test_ring_negative_tests() < 0)
> @@ -848,65 +1014,24 @@ test_ring(void)
>  	 * The test cases are split into smaller test cases to
>  	 * help clang compile faster.
>  	 */
> -	tname = "Test standard ring";
> -
> -	for (j = TEST_RING_ELEM_BULK; j <= TEST_RING_ELEM_BURST; j <<= 1)
> -		for (i = TEST_RING_THREAD_DEF;
> -					i <= TEST_RING_THREAD_MPMC; i <<=
> 1)
> -			if (test_ring_burst_bulk_tests1(i | j, 0, tname) < 0)
> -				goto test_fail;
> -
> -	for (j = TEST_RING_ELEM_BULK; j <= TEST_RING_ELEM_BURST; j <<= 1)
> -		for (i = TEST_RING_THREAD_DEF;
> -					i <= TEST_RING_THREAD_MPMC; i <<=
> 1)
> -			if (test_ring_burst_bulk_tests2(i | j, 0, tname) < 0)
> -				goto test_fail;
> -
> -	for (j = TEST_RING_ELEM_BULK; j <= TEST_RING_ELEM_BURST; j <<= 1)
> -		for (i = TEST_RING_THREAD_DEF;
> -					i <= TEST_RING_THREAD_MPMC; i <<=
> 1)
> -			if (test_ring_burst_bulk_tests3(i | j, 0, tname) < 0)
> -				goto test_fail;
> -
> -	for (j = TEST_RING_ELEM_BULK; j <= TEST_RING_ELEM_BURST; j <<= 1)
> -		for (i = TEST_RING_THREAD_DEF;
> -					i <= TEST_RING_THREAD_MPMC; i <<=
> 1)
> -			if (test_ring_burst_bulk_tests4(i | j, 0, tname) < 0)
> -				goto test_fail;
> -
> -	/* Burst and bulk operations with MT_RTS and MT_HTS sync modes
> */
> -	for (i = 0; i != RTE_DIM(test_sync_modes); i++) {
> -		for (j = TEST_RING_ELEM_BULK; j <= TEST_RING_ELEM_BURST;
> -				j <<= 1) {
> -
> -			rc = test_ring_burst_bulk_tests1(
> -				TEST_RING_THREAD_DEF | j,
> -				test_sync_modes[i].create_flags,
> -				test_sync_modes[i].name);
> -			if (rc < 0)
> -				goto test_fail;
> -
> -			rc = test_ring_burst_bulk_tests2(
> -				TEST_RING_THREAD_DEF | j,
> -				test_sync_modes[i].create_flags,
> -				test_sync_modes[i].name);
> -			if (rc < 0)
> -				goto test_fail;
> -
> -			rc = test_ring_burst_bulk_tests3(
> -				TEST_RING_THREAD_DEF | j,
> -				test_sync_modes[i].create_flags,
> -				test_sync_modes[i].name);
> -			if (rc < 0)
> -				goto test_fail;
> -
> -			rc = test_ring_burst_bulk_tests3(
> -				TEST_RING_THREAD_DEF | j,
> -				test_sync_modes[i].create_flags,
> -				test_sync_modes[i].name);
> -			if (rc < 0)
> -				goto test_fail;
> -		}
> +	for (i = 0; i != RTE_DIM(test_enqdeq_impl); i++) {
> +
> +
> +		rc = test_ring_burst_bulk_tests1(i);
> +		if (rc < 0)
> +			goto test_fail;
> +
> +		rc = test_ring_burst_bulk_tests2(i);
> +		if (rc < 0)
> +			goto test_fail;
> +
> +		rc = test_ring_burst_bulk_tests3(i);
> +		if (rc < 0)
> +			goto test_fail;
> +
> +		rc = test_ring_burst_bulk_tests4(i);
> +		if (rc < 0)
> +			goto test_fail;
>  	}
> 
>  	/* dump the ring status */
> --
> 2.17.1


  parent reply	other threads:[~2020-07-02 20:47 UTC|newest]

Thread overview: 20+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2020-04-29 17:57 Konstantin Ananyev
2020-04-29 18:19 ` Honnappa Nagarahalli
2020-04-29 22:10 ` Aaron Conole
2020-04-30  1:57 ` Honnappa Nagarahalli
2020-04-30 14:43   ` Ananyev, Konstantin
2020-05-01 17:48     ` Honnappa Nagarahalli
2020-05-05 11:59       ` Ananyev, Konstantin
2020-05-05 14:17         ` Honnappa Nagarahalli
2020-05-05 14:27           ` Ananyev, Konstantin
2020-05-05 18:13             ` Honnappa Nagarahalli
2020-05-05 18:57               ` Ananyev, Konstantin
2020-05-08  5:32                 ` Honnappa Nagarahalli
2020-05-08 10:04                   ` Ananyev, Konstantin
2020-05-09  0:33                     ` Honnappa Nagarahalli
2020-05-11 11:35                       ` Ananyev, Konstantin
2020-05-13  0:55                         ` Honnappa Nagarahalli
2020-05-13 11:20                           ` Ananyev, Konstantin
2020-05-04  9:03     ` Thomas Monjalon
2020-07-02 20:47 ` Honnappa Nagarahalli [this message]
2020-07-03 10:29   ` David Marchand

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=DB6PR0802MB22169B129DD6206B8FAC9223986D0@DB6PR0802MB2216.eurprd08.prod.outlook.com \
    --to=honnappa.nagarahalli@arm.com \
    --cc=aconole@redhat.com \
    --cc=david.marchand@redhat.com \
    --cc=dev@dpdk.org \
    --cc=konstantin.ananyev@intel.com \
    --cc=nd@arm.com \
    --cc=thomas@monjalon.net \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

DPDK patches and discussions

This inbox may be cloned and mirrored by anyone:

	git clone --mirror https://inbox.dpdk.org/dev/0 dev/git/0.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 dev dev/ https://inbox.dpdk.org/dev \
		dev@dpdk.org
	public-inbox-index dev

Example config snippet for mirrors.
Newsgroup available over NNTP:
	nntp://inbox.dpdk.org/inbox.dpdk.dev


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git