test/ring: add custom element size functional tests
[dpdk.git] / app / test / test_ring.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2019 Arm Limited
3  */
4
5 #include <rte_malloc.h>
6 #include <rte_ring.h>
7 #include <rte_ring_elem.h>
8
9 /* API type to call
10  * rte_ring_<sp/mp or sc/mc>_enqueue_<bulk/burst>
11  * TEST_RING_THREAD_DEF - Uses configured SPSC/MPMC calls
12  * TEST_RING_THREAD_SPSC - Calls SP or SC API
13  * TEST_RING_THREAD_MPMC - Calls MP or MC API
14  */
15 #define TEST_RING_THREAD_DEF 1
16 #define TEST_RING_THREAD_SPSC 2
17 #define TEST_RING_THREAD_MPMC 4
18
19 /* API type to call
20  * TEST_RING_ELEM_SINGLE - Calls single element APIs
21  * TEST_RING_ELEM_BULK - Calls bulk APIs
22  * TEST_RING_ELEM_BURST - Calls burst APIs
23  */
24 #define TEST_RING_ELEM_SINGLE 8
25 #define TEST_RING_ELEM_BULK 16
26 #define TEST_RING_ELEM_BURST 32
27
28 #define TEST_RING_IGNORE_API_TYPE ~0U
29
30 /* This function is placed here as it is required for both
31  * performance and functional tests.
32  */
33 static inline struct rte_ring*
34 test_ring_create(const char *name, int esize, unsigned int count,
35                 int socket_id, unsigned int flags)
36 {
37         /* Legacy queue APIs? */
38         if ((esize) == -1)
39                 return rte_ring_create((name), (count), (socket_id), (flags));
40         else
41                 return rte_ring_create_elem((name), (esize), (count),
42                                                 (socket_id), (flags));
43 }
44
45 static __rte_always_inline unsigned int
46 test_ring_enqueue(struct rte_ring *r, void **obj, int esize, unsigned int n,
47                         unsigned int api_type)
48 {
49         /* Legacy queue APIs? */
50         if ((esize) == -1)
51                 switch (api_type) {
52                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
53                         return rte_ring_enqueue(r, obj);
54                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
55                         return rte_ring_sp_enqueue(r, obj);
56                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
57                         return rte_ring_mp_enqueue(r, obj);
58                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
59                         return rte_ring_enqueue_bulk(r, obj, n, NULL);
60                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
61                         return rte_ring_sp_enqueue_bulk(r, obj, n, NULL);
62                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK):
63                         return rte_ring_mp_enqueue_bulk(r, obj, n, NULL);
64                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST):
65                         return rte_ring_enqueue_burst(r, obj, n, NULL);
66                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BURST):
67                         return rte_ring_sp_enqueue_burst(r, obj, n, NULL);
68                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BURST):
69                         return rte_ring_mp_enqueue_burst(r, obj, n, NULL);
70                 default:
71                         printf("Invalid API type\n");
72                         return 0;
73                 }
74         else
75                 switch (api_type) {
76                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
77                         return rte_ring_enqueue_elem(r, obj, esize);
78                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
79                         return rte_ring_sp_enqueue_elem(r, obj, esize);
80                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
81                         return rte_ring_mp_enqueue_elem(r, obj, esize);
82                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
83                         return rte_ring_enqueue_bulk_elem(r, obj, esize, n,
84                                                                 NULL);
85                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
86                         return rte_ring_sp_enqueue_bulk_elem(r, obj, esize, n,
87                                                                 NULL);
88                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK):
89                         return rte_ring_mp_enqueue_bulk_elem(r, obj, esize, n,
90                                                                 NULL);
91                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST):
92                         return rte_ring_enqueue_burst_elem(r, obj, esize, n,
93                                                                 NULL);
94                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BURST):
95                         return rte_ring_sp_enqueue_burst_elem(r, obj, esize, n,
96                                                                 NULL);
97                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BURST):
98                         return rte_ring_mp_enqueue_burst_elem(r, obj, esize, n,
99                                                                 NULL);
100                 default:
101                         printf("Invalid API type\n");
102                         return 0;
103                 }
104 }
105
106 static __rte_always_inline unsigned int
107 test_ring_dequeue(struct rte_ring *r, void **obj, int esize, unsigned int n,
108                         unsigned int api_type)
109 {
110         /* Legacy queue APIs? */
111         if ((esize) == -1)
112                 switch (api_type) {
113                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
114                         return rte_ring_dequeue(r, obj);
115                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
116                         return rte_ring_sc_dequeue(r, obj);
117                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
118                         return rte_ring_mc_dequeue(r, obj);
119                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
120                         return rte_ring_dequeue_bulk(r, obj, n, NULL);
121                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
122                         return rte_ring_sc_dequeue_bulk(r, obj, n, NULL);
123                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK):
124                         return rte_ring_mc_dequeue_bulk(r, obj, n, NULL);
125                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST):
126                         return rte_ring_dequeue_burst(r, obj, n, NULL);
127                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BURST):
128                         return rte_ring_sc_dequeue_burst(r, obj, n, NULL);
129                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BURST):
130                         return rte_ring_mc_dequeue_burst(r, obj, n, NULL);
131                 default:
132                         printf("Invalid API type\n");
133                         return 0;
134                 }
135         else
136                 switch (api_type) {
137                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_SINGLE):
138                         return rte_ring_dequeue_elem(r, obj, esize);
139                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_SINGLE):
140                         return rte_ring_sc_dequeue_elem(r, obj, esize);
141                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_SINGLE):
142                         return rte_ring_mc_dequeue_elem(r, obj, esize);
143                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BULK):
144                         return rte_ring_dequeue_bulk_elem(r, obj, esize,
145                                                                 n, NULL);
146                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BULK):
147                         return rte_ring_sc_dequeue_bulk_elem(r, obj, esize,
148                                                                 n, NULL);
149                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BULK):
150                         return rte_ring_mc_dequeue_bulk_elem(r, obj, esize,
151                                                                 n, NULL);
152                 case (TEST_RING_THREAD_DEF | TEST_RING_ELEM_BURST):
153                         return rte_ring_dequeue_burst_elem(r, obj, esize,
154                                                                 n, NULL);
155                 case (TEST_RING_THREAD_SPSC | TEST_RING_ELEM_BURST):
156                         return rte_ring_sc_dequeue_burst_elem(r, obj, esize,
157                                                                 n, NULL);
158                 case (TEST_RING_THREAD_MPMC | TEST_RING_ELEM_BURST):
159                         return rte_ring_mc_dequeue_burst_elem(r, obj, esize,
160                                                                 n, NULL);
161                 default:
162                         printf("Invalid API type\n");
163                         return 0;
164                 }
165 }
166
167 /* This function is placed here as it is required for both
168  * performance and functional tests.
169  */
170 static __rte_always_inline void *
171 test_ring_calloc(unsigned int rsize, int esize)
172 {
173         unsigned int sz;
174         void *p;
175
176         /* Legacy queue APIs? */
177         if (esize == -1)
178                 sz = sizeof(void *);
179         else
180                 sz = esize;
181
182         p = rte_zmalloc(NULL, rsize * sz, RTE_CACHE_LINE_SIZE);
183         if (p == NULL)
184                 printf("Failed to allocate memory\n");
185
186         return p;
187 }