1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2010-2017 Intel Corporation
9 #include <rte_mempool.h>
10 #include <rte_cycles.h>
11 #include <rte_common.h>
13 #include <rte_distributor.h>
14 #include <rte_pause.h>
16 #define ITER_POWER_CL 25 /* log 2 of how many iterations for Cache Line test */
17 #define ITER_POWER 21 /* log 2 of how many iterations we do when timing. */
19 #define BIG_BATCH 1024
21 /* static vars - zero initialized by default */
22 static volatile int quit
;
23 static volatile unsigned worker_idx
;
26 volatile unsigned handled_packets
;
27 } __rte_cache_aligned
;
28 struct worker_stats worker_stats
[RTE_MAX_LCORE
];
31 * worker thread used for testing the time to do a round-trip of a cache
32 * line between two cores and back again
35 flip_bit(volatile uint64_t *arg
)
38 while (old_val
!= 2) {
48 * test case to time the number of cycles to round-trip a cache line between
49 * two cores and back again.
52 time_cache_line_switch(void)
54 /* allocate a full cache line for data, we use only first byte of it */
55 uint64_t data
[RTE_CACHE_LINE_SIZE
*3 / sizeof(uint64_t)];
57 unsigned i
, slaveid
= rte_get_next_lcore(rte_lcore_id(), 0, 0);
58 volatile uint64_t *pdata
= &data
[0];
60 rte_eal_remote_launch((lcore_function_t
*)flip_bit
, &data
[0], slaveid
);
64 const uint64_t start_time
= rte_rdtsc();
65 for (i
= 0; i
< (1 << ITER_POWER_CL
); i
++) {
70 const uint64_t end_time
= rte_rdtsc();
75 rte_eal_wait_lcore(slaveid
);
76 printf("==== Cache line switch test ===\n");
77 printf("Time for %u iterations = %"PRIu64
" ticks\n", (1<<ITER_POWER_CL
),
79 printf("Ticks per iteration = %"PRIu64
"\n\n",
80 (end_time
-start_time
) >> ITER_POWER_CL
);
84 * returns the total count of the number of packets handled by the worker
85 * functions given below.
88 total_packet_count(void)
90 unsigned i
, count
= 0;
91 for (i
= 0; i
< worker_idx
; i
++)
92 count
+= worker_stats
[i
].handled_packets
;
96 /* resets the packet counts for a new test */
98 clear_packet_count(void)
100 memset(&worker_stats
, 0, sizeof(worker_stats
));
104 * This is the basic worker function for performance tests.
105 * it does nothing but return packets and count them.
108 handle_work(void *arg
)
110 struct rte_distributor
*d
= arg
;
111 unsigned int count
= 0;
112 unsigned int num
= 0;
114 unsigned int id
= __sync_fetch_and_add(&worker_idx
, 1);
115 struct rte_mbuf
*buf
[8] __rte_cache_aligned
;
117 for (i
= 0; i
< 8; i
++)
120 num
= rte_distributor_get_pkt(d
, id
, buf
, buf
, num
);
122 worker_stats
[id
].handled_packets
+= num
;
124 num
= rte_distributor_get_pkt(d
, id
, buf
, buf
, num
);
126 worker_stats
[id
].handled_packets
+= num
;
128 rte_distributor_return_pkt(d
, id
, buf
, num
);
133 * This basic performance test just repeatedly sends in 32 packets at a time
134 * to the distributor and verifies at the end that we got them all in the worker
135 * threads and finally how long per packet the processing took.
138 perf_test(struct rte_distributor
*d
, struct rte_mempool
*p
)
142 struct rte_mbuf
*bufs
[BURST
];
144 clear_packet_count();
145 if (rte_mempool_get_bulk(p
, (void *)bufs
, BURST
) != 0) {
146 printf("Error getting mbufs from pool\n");
149 /* ensure we have different hash value for each pkt */
150 for (i
= 0; i
< BURST
; i
++)
151 bufs
[i
]->hash
.usr
= i
;
154 for (i
= 0; i
< (1<<ITER_POWER
); i
++)
155 rte_distributor_process(d
, bufs
, BURST
);
160 rte_distributor_process(d
, NULL
, 0);
161 } while (total_packet_count() < (BURST
<< ITER_POWER
));
163 rte_distributor_clear_returns(d
);
165 printf("Time per burst: %"PRIu64
"\n", (end
- start
) >> ITER_POWER
);
166 printf("Time per packet: %"PRIu64
"\n\n",
167 ((end
- start
) >> ITER_POWER
)/BURST
);
168 rte_mempool_put_bulk(p
, (void *)bufs
, BURST
);
170 for (i
= 0; i
< rte_lcore_count() - 1; i
++)
171 printf("Worker %u handled %u packets\n", i
,
172 worker_stats
[i
].handled_packets
);
173 printf("Total packets: %u (%x)\n", total_packet_count(),
174 total_packet_count());
175 printf("=== Perf test done ===\n\n");
180 /* Useful function which ensures that all worker functions terminate */
182 quit_workers(struct rte_distributor
*d
, struct rte_mempool
*p
)
184 const unsigned int num_workers
= rte_lcore_count() - 1;
186 struct rte_mbuf
*bufs
[RTE_MAX_LCORE
];
188 rte_mempool_get_bulk(p
, (void *)bufs
, num_workers
);
191 for (i
= 0; i
< num_workers
; i
++)
192 bufs
[i
]->hash
.usr
= i
<< 1;
193 rte_distributor_process(d
, bufs
, num_workers
);
195 rte_mempool_put_bulk(p
, (void *)bufs
, num_workers
);
197 rte_distributor_process(d
, NULL
, 0);
198 rte_eal_mp_wait_lcore();
204 test_distributor_perf(void)
206 static struct rte_distributor
*ds
;
207 static struct rte_distributor
*db
;
208 static struct rte_mempool
*p
;
210 if (rte_lcore_count() < 2) {
211 printf("ERROR: not enough cores to test distributor\n");
215 /* first time how long it takes to round-trip a cache line */
216 time_cache_line_switch();
219 ds
= rte_distributor_create("Test_perf", rte_socket_id(),
220 rte_lcore_count() - 1,
221 RTE_DIST_ALG_SINGLE
);
223 printf("Error creating distributor\n");
227 rte_distributor_clear_returns(ds
);
231 db
= rte_distributor_create("Test_burst", rte_socket_id(),
232 rte_lcore_count() - 1,
235 printf("Error creating burst distributor\n");
239 rte_distributor_clear_returns(db
);
242 const unsigned nb_bufs
= (511 * rte_lcore_count()) < BIG_BATCH
?
243 (BIG_BATCH
* 2) - 1 : (511 * rte_lcore_count());
245 p
= rte_pktmbuf_pool_create("DPT_MBUF_POOL", nb_bufs
, BURST
,
246 0, RTE_MBUF_DEFAULT_BUF_SIZE
, rte_socket_id());
248 printf("Error creating mempool\n");
253 printf("=== Performance test of distributor (single mode) ===\n");
254 rte_eal_mp_remote_launch(handle_work
, ds
, SKIP_MASTER
);
255 if (perf_test(ds
, p
) < 0)
259 printf("=== Performance test of distributor (burst mode) ===\n");
260 rte_eal_mp_remote_launch(handle_work
, db
, SKIP_MASTER
);
261 if (perf_test(db
, p
) < 0)
268 REGISTER_TEST_COMMAND(distributor_perf_autotest
, test_distributor_perf
);