1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017 Cavium, Inc
5 #include "test_order_common.h"
8 order_test_result(struct evt_test *test, struct evt_options *opt)
11 struct test_order *t = evt_test_priv(test);
17 order_producer(void *arg)
19 struct prod_data *p = arg;
20 struct test_order *t = p->t;
21 struct evt_options *opt = t->opt;
22 const uint8_t dev_id = p->dev_id;
23 const uint8_t port = p->port_id;
24 struct rte_mempool *pool = t->pool;
25 const uint64_t nb_pkts = t->nb_pkts;
26 uint32_t *producer_flow_seq = t->producer_flow_seq;
27 const uint32_t nb_flows = t->nb_flows;
32 if (opt->verbose_level > 1)
33 printf("%s(): lcore %d dev_id %d port=%d queue=%d\n",
34 __func__, rte_lcore_id(), dev_id, port, p->queue_id);
37 ev.op = RTE_EVENT_OP_NEW;
38 ev.queue_id = p->queue_id;
39 ev.sched_type = RTE_SCHED_TYPE_ORDERED;
40 ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
41 ev.event_type = RTE_EVENT_TYPE_CPU;
42 ev.sub_event_type = 0; /* stage 0 */
44 while (count < nb_pkts && t->err == false) {
45 m = rte_pktmbuf_alloc(pool);
49 const uint32_t flow = (uintptr_t)m % nb_flows;
50 /* Maintain seq number per flow */
51 m->seqn = producer_flow_seq[flow]++;
57 while (rte_event_enqueue_burst(dev_id, port, &ev, 1) != 1) {
69 order_opt_check(struct evt_options *opt)
71 if (opt->prod_type != EVT_PROD_TYPE_SYNT) {
72 evt_err("Invalid producer type '%s' valid producer '%s'",
73 evt_prod_id_to_name(opt->prod_type),
74 evt_prod_id_to_name(EVT_PROD_TYPE_SYNT));
78 /* 1 producer + N workers + 1 master */
79 if (rte_lcore_count() < 3) {
80 evt_err("test need minimum 3 lcores");
84 /* Validate worker lcores */
85 if (evt_lcores_has_overlap(opt->wlcores, rte_get_master_lcore())) {
86 evt_err("worker lcores overlaps with master lcore");
90 if (evt_nr_active_lcores(opt->plcores) == 0) {
91 evt_err("missing the producer lcore");
95 if (evt_nr_active_lcores(opt->plcores) != 1) {
96 evt_err("only one producer lcore must be selected");
100 int plcore = evt_get_first_active_lcore(opt->plcores);
103 evt_err("failed to find active producer");
107 if (evt_lcores_has_overlap(opt->wlcores, plcore)) {
108 evt_err("worker lcores overlaps producer lcore");
111 if (evt_has_disabled_lcore(opt->wlcores)) {
112 evt_err("one or more workers lcores are not enabled");
115 if (!evt_has_active_lcore(opt->wlcores)) {
116 evt_err("minimum one worker is required");
120 /* Validate producer lcore */
121 if (plcore == (int)rte_get_master_lcore()) {
122 evt_err("producer lcore and master lcore should be different");
125 if (!rte_lcore_is_enabled(plcore)) {
126 evt_err("producer lcore is not enabled");
131 if (opt->nb_pkts == 0)
132 opt->nb_pkts = INT64_MAX;
138 order_test_setup(struct evt_test *test, struct evt_options *opt)
142 test_order = rte_zmalloc_socket(test->name, sizeof(struct test_order),
143 RTE_CACHE_LINE_SIZE, opt->socket_id);
144 if (test_order == NULL) {
145 evt_err("failed to allocate test_order memory");
148 test->test_priv = test_order;
150 struct test_order *t = evt_test_priv(test);
152 t->producer_flow_seq = rte_zmalloc_socket("test_producer_flow_seq",
153 sizeof(*t->producer_flow_seq) * opt->nb_flows,
154 RTE_CACHE_LINE_SIZE, opt->socket_id);
156 if (t->producer_flow_seq == NULL) {
157 evt_err("failed to allocate t->producer_flow_seq memory");
161 t->expected_flow_seq = rte_zmalloc_socket("test_expected_flow_seq",
162 sizeof(*t->expected_flow_seq) * opt->nb_flows,
163 RTE_CACHE_LINE_SIZE, opt->socket_id);
165 if (t->expected_flow_seq == NULL) {
166 evt_err("failed to allocate t->expected_flow_seq memory");
169 rte_atomic64_set(&t->outstand_pkts, opt->nb_pkts);
171 t->nb_pkts = opt->nb_pkts;
172 t->nb_flows = opt->nb_flows;
173 t->result = EVT_TEST_FAILED;
178 rte_free(t->producer_flow_seq);
180 rte_free(test->test_priv);
186 order_test_destroy(struct evt_test *test, struct evt_options *opt)
189 struct test_order *t = evt_test_priv(test);
191 rte_free(t->expected_flow_seq);
192 rte_free(t->producer_flow_seq);
193 rte_free(test->test_priv);
197 order_mempool_setup(struct evt_test *test, struct evt_options *opt)
199 struct test_order *t = evt_test_priv(test);
201 t->pool = rte_pktmbuf_pool_create(test->name, opt->pool_sz,
203 512, /* Use very small mbufs */
205 if (t->pool == NULL) {
206 evt_err("failed to create mempool");
214 order_mempool_destroy(struct evt_test *test, struct evt_options *opt)
217 struct test_order *t = evt_test_priv(test);
219 rte_mempool_free(t->pool);
223 order_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
227 rte_event_dev_stop(opt->dev_id);
228 rte_event_dev_close(opt->dev_id);
232 order_opt_dump(struct evt_options *opt)
234 evt_dump_producer_lcores(opt);
235 evt_dump("nb_wrker_lcores", "%d", evt_nr_active_lcores(opt->wlcores));
236 evt_dump_worker_lcores(opt);
237 evt_dump("nb_evdev_ports", "%d", order_nb_event_ports(opt));
241 order_launch_lcores(struct evt_test *test, struct evt_options *opt,
242 int (*worker)(void *))
245 struct test_order *t = evt_test_priv(test);
249 RTE_LCORE_FOREACH_SLAVE(lcore_id) {
250 if (!(opt->wlcores[lcore_id]))
253 ret = rte_eal_remote_launch(worker, &t->worker[wkr_idx],
256 evt_err("failed to launch worker %d", lcore_id);
262 /* launch producer */
263 int plcore = evt_get_first_active_lcore(opt->plcores);
265 ret = rte_eal_remote_launch(order_producer, &t->prod, plcore);
267 evt_err("failed to launch order_producer %d", plcore);
271 uint64_t cycles = rte_get_timer_cycles();
272 int64_t old_remaining = -1;
274 while (t->err == false) {
275 uint64_t new_cycles = rte_get_timer_cycles();
276 int64_t remaining = rte_atomic64_read(&t->outstand_pkts);
278 if (remaining <= 0) {
279 t->result = EVT_TEST_SUCCESS;
283 if (new_cycles - cycles > rte_get_timer_hz() * 1) {
284 printf(CLGRN"\r%"PRId64""CLNRM, remaining);
286 if (old_remaining == remaining) {
287 rte_event_dev_dump(opt->dev_id, stdout);
288 evt_err("No schedules for seconds, deadlock");
293 old_remaining = remaining;
303 order_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
304 uint8_t nb_workers, uint8_t nb_queues)
308 struct test_order *t = evt_test_priv(test);
309 struct rte_event_dev_info dev_info;
311 memset(&dev_info, 0, sizeof(struct rte_event_dev_info));
312 ret = rte_event_dev_info_get(opt->dev_id, &dev_info);
314 evt_err("failed to get eventdev info %d", opt->dev_id);
318 if (opt->wkr_deq_dep > dev_info.max_event_port_dequeue_depth)
319 opt->wkr_deq_dep = dev_info.max_event_port_dequeue_depth;
321 /* port configuration */
322 const struct rte_event_port_conf p_conf = {
323 .dequeue_depth = opt->wkr_deq_dep,
324 .enqueue_depth = dev_info.max_event_port_dequeue_depth,
325 .new_event_threshold = dev_info.max_num_events,
328 /* setup one port per worker, linking to all queues */
329 for (port = 0; port < nb_workers; port++) {
330 struct worker_data *w = &t->worker[port];
332 w->dev_id = opt->dev_id;
336 ret = rte_event_port_setup(opt->dev_id, port, &p_conf);
338 evt_err("failed to setup port %d", port);
342 ret = rte_event_port_link(opt->dev_id, port, NULL, NULL, 0);
343 if (ret != nb_queues) {
344 evt_err("failed to link all queues to port %d", port);
348 struct prod_data *p = &t->prod;
350 p->dev_id = opt->dev_id;
351 p->port_id = port; /* last port */
355 ret = rte_event_port_setup(opt->dev_id, port, &p_conf);
357 evt_err("failed to setup producer port %d", port);