test: fix autotest list
[dpdk.git] / test / test / test_ring_perf.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5
6 #include <stdio.h>
7 #include <inttypes.h>
8 #include <rte_ring.h>
9 #include <rte_cycles.h>
10 #include <rte_launch.h>
11 #include <rte_pause.h>
12
13 #include "test.h"
14
15 /*
16  * Ring
17  * ====
18  *
19  * Measures performance of various operations using rdtsc
20  *  * Empty ring dequeue
21  *  * Enqueue/dequeue of bursts in 1 threads
22  *  * Enqueue/dequeue of bursts in 2 threads
23  */
24
25 #define RING_NAME "RING_PERF"
26 #define RING_SIZE 4096
27 #define MAX_BURST 32
28
29 /*
30  * the sizes to enqueue and dequeue in testing
31  * (marked volatile so they won't be seen as compile-time constants)
32  */
33 static const volatile unsigned bulk_sizes[] = { 8, 32 };
34
35 struct lcore_pair {
36         unsigned c1, c2;
37 };
38
39 static volatile unsigned lcore_count = 0;
40
41 /**** Functions to analyse our core mask to get cores for different tests ***/
42
43 static int
44 get_two_hyperthreads(struct lcore_pair *lcp)
45 {
46         unsigned id1, id2;
47         unsigned c1, c2, s1, s2;
48         RTE_LCORE_FOREACH(id1) {
49                 /* inner loop just re-reads all id's. We could skip the first few
50                  * elements, but since number of cores is small there is little point
51                  */
52                 RTE_LCORE_FOREACH(id2) {
53                         if (id1 == id2)
54                                 continue;
55                         c1 = lcore_config[id1].core_id;
56                         c2 = lcore_config[id2].core_id;
57                         s1 = lcore_config[id1].socket_id;
58                         s2 = lcore_config[id2].socket_id;
59                         if ((c1 == c2) && (s1 == s2)){
60                                 lcp->c1 = id1;
61                                 lcp->c2 = id2;
62                                 return 0;
63                         }
64                 }
65         }
66         return 1;
67 }
68
69 static int
70 get_two_cores(struct lcore_pair *lcp)
71 {
72         unsigned id1, id2;
73         unsigned c1, c2, s1, s2;
74         RTE_LCORE_FOREACH(id1) {
75                 RTE_LCORE_FOREACH(id2) {
76                         if (id1 == id2)
77                                 continue;
78                         c1 = lcore_config[id1].core_id;
79                         c2 = lcore_config[id2].core_id;
80                         s1 = lcore_config[id1].socket_id;
81                         s2 = lcore_config[id2].socket_id;
82                         if ((c1 != c2) && (s1 == s2)){
83                                 lcp->c1 = id1;
84                                 lcp->c2 = id2;
85                                 return 0;
86                         }
87                 }
88         }
89         return 1;
90 }
91
92 static int
93 get_two_sockets(struct lcore_pair *lcp)
94 {
95         unsigned id1, id2;
96         unsigned s1, s2;
97         RTE_LCORE_FOREACH(id1) {
98                 RTE_LCORE_FOREACH(id2) {
99                         if (id1 == id2)
100                                 continue;
101                         s1 = lcore_config[id1].socket_id;
102                         s2 = lcore_config[id2].socket_id;
103                         if (s1 != s2){
104                                 lcp->c1 = id1;
105                                 lcp->c2 = id2;
106                                 return 0;
107                         }
108                 }
109         }
110         return 1;
111 }
112
113 /* Get cycle counts for dequeuing from an empty ring. Should be 2 or 3 cycles */
114 static void
115 test_empty_dequeue(struct rte_ring *r)
116 {
117         const unsigned iter_shift = 26;
118         const unsigned iterations = 1<<iter_shift;
119         unsigned i = 0;
120         void *burst[MAX_BURST];
121
122         const uint64_t sc_start = rte_rdtsc();
123         for (i = 0; i < iterations; i++)
124                 rte_ring_sc_dequeue_bulk(r, burst, bulk_sizes[0], NULL);
125         const uint64_t sc_end = rte_rdtsc();
126
127         const uint64_t mc_start = rte_rdtsc();
128         for (i = 0; i < iterations; i++)
129                 rte_ring_mc_dequeue_bulk(r, burst, bulk_sizes[0], NULL);
130         const uint64_t mc_end = rte_rdtsc();
131
132         printf("SC empty dequeue: %.2F\n",
133                         (double)(sc_end-sc_start) / iterations);
134         printf("MC empty dequeue: %.2F\n",
135                         (double)(mc_end-mc_start) / iterations);
136 }
137
138 /*
139  * for the separate enqueue and dequeue threads they take in one param
140  * and return two. Input = burst size, output = cycle average for sp/sc & mp/mc
141  */
142 struct thread_params {
143         struct rte_ring *r;
144         unsigned size;        /* input value, the burst size */
145         double spsc, mpmc;    /* output value, the single or multi timings */
146 };
147
148 /*
149  * Function that uses rdtsc to measure timing for ring enqueue. Needs pair
150  * thread running dequeue_bulk function
151  */
152 static int
153 enqueue_bulk(void *p)
154 {
155         const unsigned iter_shift = 23;
156         const unsigned iterations = 1<<iter_shift;
157         struct thread_params *params = p;
158         struct rte_ring *r = params->r;
159         const unsigned size = params->size;
160         unsigned i;
161         void *burst[MAX_BURST] = {0};
162
163         if ( __sync_add_and_fetch(&lcore_count, 1) != 2 )
164                 while(lcore_count != 2)
165                         rte_pause();
166
167         const uint64_t sp_start = rte_rdtsc();
168         for (i = 0; i < iterations; i++)
169                 while (rte_ring_sp_enqueue_bulk(r, burst, size, NULL) == 0)
170                         rte_pause();
171         const uint64_t sp_end = rte_rdtsc();
172
173         const uint64_t mp_start = rte_rdtsc();
174         for (i = 0; i < iterations; i++)
175                 while (rte_ring_mp_enqueue_bulk(r, burst, size, NULL) == 0)
176                         rte_pause();
177         const uint64_t mp_end = rte_rdtsc();
178
179         params->spsc = ((double)(sp_end - sp_start))/(iterations*size);
180         params->mpmc = ((double)(mp_end - mp_start))/(iterations*size);
181         return 0;
182 }
183
184 /*
185  * Function that uses rdtsc to measure timing for ring dequeue. Needs pair
186  * thread running enqueue_bulk function
187  */
188 static int
189 dequeue_bulk(void *p)
190 {
191         const unsigned iter_shift = 23;
192         const unsigned iterations = 1<<iter_shift;
193         struct thread_params *params = p;
194         struct rte_ring *r = params->r;
195         const unsigned size = params->size;
196         unsigned i;
197         void *burst[MAX_BURST] = {0};
198
199         if ( __sync_add_and_fetch(&lcore_count, 1) != 2 )
200                 while(lcore_count != 2)
201                         rte_pause();
202
203         const uint64_t sc_start = rte_rdtsc();
204         for (i = 0; i < iterations; i++)
205                 while (rte_ring_sc_dequeue_bulk(r, burst, size, NULL) == 0)
206                         rte_pause();
207         const uint64_t sc_end = rte_rdtsc();
208
209         const uint64_t mc_start = rte_rdtsc();
210         for (i = 0; i < iterations; i++)
211                 while (rte_ring_mc_dequeue_bulk(r, burst, size, NULL) == 0)
212                         rte_pause();
213         const uint64_t mc_end = rte_rdtsc();
214
215         params->spsc = ((double)(sc_end - sc_start))/(iterations*size);
216         params->mpmc = ((double)(mc_end - mc_start))/(iterations*size);
217         return 0;
218 }
219
220 /*
221  * Function that calls the enqueue and dequeue bulk functions on pairs of cores.
222  * used to measure ring perf between hyperthreads, cores and sockets.
223  */
224 static void
225 run_on_core_pair(struct lcore_pair *cores, struct rte_ring *r,
226                 lcore_function_t f1, lcore_function_t f2)
227 {
228         struct thread_params param1 = {0}, param2 = {0};
229         unsigned i;
230         for (i = 0; i < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); i++) {
231                 lcore_count = 0;
232                 param1.size = param2.size = bulk_sizes[i];
233                 param1.r = param2.r = r;
234                 if (cores->c1 == rte_get_master_lcore()) {
235                         rte_eal_remote_launch(f2, &param2, cores->c2);
236                         f1(&param1);
237                         rte_eal_wait_lcore(cores->c2);
238                 } else {
239                         rte_eal_remote_launch(f1, &param1, cores->c1);
240                         rte_eal_remote_launch(f2, &param2, cores->c2);
241                         rte_eal_wait_lcore(cores->c1);
242                         rte_eal_wait_lcore(cores->c2);
243                 }
244                 printf("SP/SC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[i],
245                                 param1.spsc + param2.spsc);
246                 printf("MP/MC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[i],
247                                 param1.mpmc + param2.mpmc);
248         }
249 }
250
251 /*
252  * Test function that determines how long an enqueue + dequeue of a single item
253  * takes on a single lcore. Result is for comparison with the bulk enq+deq.
254  */
255 static void
256 test_single_enqueue_dequeue(struct rte_ring *r)
257 {
258         const unsigned iter_shift = 24;
259         const unsigned iterations = 1<<iter_shift;
260         unsigned i = 0;
261         void *burst = NULL;
262
263         const uint64_t sc_start = rte_rdtsc();
264         for (i = 0; i < iterations; i++) {
265                 rte_ring_sp_enqueue(r, burst);
266                 rte_ring_sc_dequeue(r, &burst);
267         }
268         const uint64_t sc_end = rte_rdtsc();
269
270         const uint64_t mc_start = rte_rdtsc();
271         for (i = 0; i < iterations; i++) {
272                 rte_ring_mp_enqueue(r, burst);
273                 rte_ring_mc_dequeue(r, &burst);
274         }
275         const uint64_t mc_end = rte_rdtsc();
276
277         printf("SP/SC single enq/dequeue: %"PRIu64"\n",
278                         (sc_end-sc_start) >> iter_shift);
279         printf("MP/MC single enq/dequeue: %"PRIu64"\n",
280                         (mc_end-mc_start) >> iter_shift);
281 }
282
283 /*
284  * Test that does both enqueue and dequeue on a core using the burst() API calls
285  * instead of the bulk() calls used in other tests. Results should be the same
286  * as for the bulk function called on a single lcore.
287  */
288 static void
289 test_burst_enqueue_dequeue(struct rte_ring *r)
290 {
291         const unsigned iter_shift = 23;
292         const unsigned iterations = 1<<iter_shift;
293         unsigned sz, i = 0;
294         void *burst[MAX_BURST] = {0};
295
296         for (sz = 0; sz < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); sz++) {
297                 const uint64_t sc_start = rte_rdtsc();
298                 for (i = 0; i < iterations; i++) {
299                         rte_ring_sp_enqueue_burst(r, burst,
300                                         bulk_sizes[sz], NULL);
301                         rte_ring_sc_dequeue_burst(r, burst,
302                                         bulk_sizes[sz], NULL);
303                 }
304                 const uint64_t sc_end = rte_rdtsc();
305
306                 const uint64_t mc_start = rte_rdtsc();
307                 for (i = 0; i < iterations; i++) {
308                         rte_ring_mp_enqueue_burst(r, burst,
309                                         bulk_sizes[sz], NULL);
310                         rte_ring_mc_dequeue_burst(r, burst,
311                                         bulk_sizes[sz], NULL);
312                 }
313                 const uint64_t mc_end = rte_rdtsc();
314
315                 uint64_t mc_avg = ((mc_end-mc_start) >> iter_shift) / bulk_sizes[sz];
316                 uint64_t sc_avg = ((sc_end-sc_start) >> iter_shift) / bulk_sizes[sz];
317
318                 printf("SP/SC burst enq/dequeue (size: %u): %"PRIu64"\n", bulk_sizes[sz],
319                                 sc_avg);
320                 printf("MP/MC burst enq/dequeue (size: %u): %"PRIu64"\n", bulk_sizes[sz],
321                                 mc_avg);
322         }
323 }
324
325 /* Times enqueue and dequeue on a single lcore */
326 static void
327 test_bulk_enqueue_dequeue(struct rte_ring *r)
328 {
329         const unsigned iter_shift = 23;
330         const unsigned iterations = 1<<iter_shift;
331         unsigned sz, i = 0;
332         void *burst[MAX_BURST] = {0};
333
334         for (sz = 0; sz < sizeof(bulk_sizes)/sizeof(bulk_sizes[0]); sz++) {
335                 const uint64_t sc_start = rte_rdtsc();
336                 for (i = 0; i < iterations; i++) {
337                         rte_ring_sp_enqueue_bulk(r, burst,
338                                         bulk_sizes[sz], NULL);
339                         rte_ring_sc_dequeue_bulk(r, burst,
340                                         bulk_sizes[sz], NULL);
341                 }
342                 const uint64_t sc_end = rte_rdtsc();
343
344                 const uint64_t mc_start = rte_rdtsc();
345                 for (i = 0; i < iterations; i++) {
346                         rte_ring_mp_enqueue_bulk(r, burst,
347                                         bulk_sizes[sz], NULL);
348                         rte_ring_mc_dequeue_bulk(r, burst,
349                                         bulk_sizes[sz], NULL);
350                 }
351                 const uint64_t mc_end = rte_rdtsc();
352
353                 double sc_avg = ((double)(sc_end-sc_start) /
354                                 (iterations * bulk_sizes[sz]));
355                 double mc_avg = ((double)(mc_end-mc_start) /
356                                 (iterations * bulk_sizes[sz]));
357
358                 printf("SP/SC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[sz],
359                                 sc_avg);
360                 printf("MP/MC bulk enq/dequeue (size: %u): %.2F\n", bulk_sizes[sz],
361                                 mc_avg);
362         }
363 }
364
365 static int
366 test_ring_perf(void)
367 {
368         struct lcore_pair cores;
369         struct rte_ring *r = NULL;
370
371         r = rte_ring_create(RING_NAME, RING_SIZE, rte_socket_id(), 0);
372         if (r == NULL)
373                 return -1;
374
375         printf("### Testing single element and burst enq/deq ###\n");
376         test_single_enqueue_dequeue(r);
377         test_burst_enqueue_dequeue(r);
378
379         printf("\n### Testing empty dequeue ###\n");
380         test_empty_dequeue(r);
381
382         printf("\n### Testing using a single lcore ###\n");
383         test_bulk_enqueue_dequeue(r);
384
385         if (get_two_hyperthreads(&cores) == 0) {
386                 printf("\n### Testing using two hyperthreads ###\n");
387                 run_on_core_pair(&cores, r, enqueue_bulk, dequeue_bulk);
388         }
389         if (get_two_cores(&cores) == 0) {
390                 printf("\n### Testing using two physical cores ###\n");
391                 run_on_core_pair(&cores, r, enqueue_bulk, dequeue_bulk);
392         }
393         if (get_two_sockets(&cores) == 0) {
394                 printf("\n### Testing using two NUMA nodes ###\n");
395                 run_on_core_pair(&cores, r, enqueue_bulk, dequeue_bulk);
396         }
397         rte_ring_free(r);
398         return 0;
399 }
400
401 REGISTER_TEST_COMMAND(ring_perf_autotest, test_ring_perf);