app/testpmd: remove port status check from TM command
[dpdk.git] / app / test-eventdev / test_order_common.c
1 /*
2  *   BSD LICENSE
3  *
4  *   Copyright (C) Cavium, Inc 2017.
5  *
6  *   Redistribution and use in source and binary forms, with or without
7  *   modification, are permitted provided that the following conditions
8  *   are met:
9  *
10  *     * Redistributions of source code must retain the above copyright
11  *       notice, this list of conditions and the following disclaimer.
12  *     * Redistributions in binary form must reproduce the above copyright
13  *       notice, this list of conditions and the following disclaimer in
14  *       the documentation and/or other materials provided with the
15  *       distribution.
16  *     * Neither the name of Cavium, Inc nor the names of its
17  *       contributors may be used to endorse or promote products derived
18  *       from this software without specific prior written permission.
19  *
20  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 #include "test_order_common.h"
34
35 int
36 order_test_result(struct evt_test *test, struct evt_options *opt)
37 {
38         RTE_SET_USED(opt);
39         struct test_order *t = evt_test_priv(test);
40
41         return t->result;
42 }
43
44 static inline int
45 order_producer(void *arg)
46 {
47         struct prod_data *p  = arg;
48         struct test_order *t = p->t;
49         struct evt_options *opt = t->opt;
50         const uint8_t dev_id = p->dev_id;
51         const uint8_t port = p->port_id;
52         struct rte_mempool *pool = t->pool;
53         const uint64_t nb_pkts = t->nb_pkts;
54         uint32_t *producer_flow_seq = t->producer_flow_seq;
55         const uint32_t nb_flows = t->nb_flows;
56         uint64_t count = 0;
57         struct rte_mbuf *m;
58         struct rte_event ev;
59
60         if (opt->verbose_level > 1)
61                 printf("%s(): lcore %d dev_id %d port=%d queue=%d\n",
62                          __func__, rte_lcore_id(), dev_id, port, p->queue_id);
63
64         ev.event = 0;
65         ev.op = RTE_EVENT_OP_NEW;
66         ev.queue_id = p->queue_id;
67         ev.sched_type = RTE_SCHED_TYPE_ORDERED;
68         ev.priority = RTE_EVENT_DEV_PRIORITY_NORMAL;
69         ev.event_type =  RTE_EVENT_TYPE_CPU;
70         ev.sub_event_type = 0; /* stage 0 */
71
72         while (count < nb_pkts && t->err == false) {
73                 m = rte_pktmbuf_alloc(pool);
74                 if (m == NULL)
75                         continue;
76
77                 const uint32_t flow = (uintptr_t)m % nb_flows;
78                 /* Maintain seq number per flow */
79                 m->seqn = producer_flow_seq[flow]++;
80
81                 ev.flow_id = flow;
82                 ev.mbuf = m;
83
84                 while (rte_event_enqueue_burst(dev_id, port, &ev, 1) != 1) {
85                         if (t->err)
86                                 break;
87                         rte_pause();
88                 }
89
90                 count++;
91         }
92         return 0;
93 }
94
95 int
96 order_opt_check(struct evt_options *opt)
97 {
98         /* 1 producer + N workers + 1 master */
99         if (rte_lcore_count() < 3) {
100                 evt_err("test need minimum 3 lcores");
101                 return -1;
102         }
103
104         /* Validate worker lcores */
105         if (evt_lcores_has_overlap(opt->wlcores, rte_get_master_lcore())) {
106                 evt_err("worker lcores overlaps with master lcore");
107                 return -1;
108         }
109
110         if (evt_nr_active_lcores(opt->plcores) == 0) {
111                 evt_err("missing the producer lcore");
112                 return -1;
113         }
114
115         if (evt_nr_active_lcores(opt->plcores) != 1) {
116                 evt_err("only one producer lcore must be selected");
117                 return -1;
118         }
119
120         int plcore = evt_get_first_active_lcore(opt->plcores);
121
122         if (plcore < 0) {
123                 evt_err("failed to find active producer");
124                 return plcore;
125         }
126
127         if (evt_lcores_has_overlap(opt->wlcores, plcore)) {
128                 evt_err("worker lcores overlaps producer lcore");
129                 return -1;
130         }
131         if (evt_has_disabled_lcore(opt->wlcores)) {
132                 evt_err("one or more workers lcores are not enabled");
133                 return -1;
134         }
135         if (!evt_has_active_lcore(opt->wlcores)) {
136                 evt_err("minimum one worker is required");
137                 return -1;
138         }
139
140         /* Validate producer lcore */
141         if (plcore == (int)rte_get_master_lcore()) {
142                 evt_err("producer lcore and master lcore should be different");
143                 return -1;
144         }
145         if (!rte_lcore_is_enabled(plcore)) {
146                 evt_err("producer lcore is not enabled");
147                 return -1;
148         }
149
150         /* Fixups */
151         if (opt->nb_pkts == 0)
152                 opt->nb_pkts = INT64_MAX;
153
154         return 0;
155 }
156
157 int
158 order_test_setup(struct evt_test *test, struct evt_options *opt)
159 {
160         void *test_order;
161
162         test_order = rte_zmalloc_socket(test->name, sizeof(struct test_order),
163                                 RTE_CACHE_LINE_SIZE, opt->socket_id);
164         if (test_order  == NULL) {
165                 evt_err("failed to allocate test_order memory");
166                 goto nomem;
167         }
168         test->test_priv = test_order;
169
170         struct test_order *t = evt_test_priv(test);
171
172         t->producer_flow_seq = rte_zmalloc_socket("test_producer_flow_seq",
173                                  sizeof(*t->producer_flow_seq) * opt->nb_flows,
174                                 RTE_CACHE_LINE_SIZE, opt->socket_id);
175
176         if (t->producer_flow_seq  == NULL) {
177                 evt_err("failed to allocate t->producer_flow_seq memory");
178                 goto prod_nomem;
179         }
180
181         t->expected_flow_seq = rte_zmalloc_socket("test_expected_flow_seq",
182                                  sizeof(*t->expected_flow_seq) * opt->nb_flows,
183                                 RTE_CACHE_LINE_SIZE, opt->socket_id);
184
185         if (t->expected_flow_seq  == NULL) {
186                 evt_err("failed to allocate t->expected_flow_seq memory");
187                 goto exp_nomem;
188         }
189         rte_atomic64_set(&t->outstand_pkts, opt->nb_pkts);
190         t->err = false;
191         t->nb_pkts = opt->nb_pkts;
192         t->nb_flows = opt->nb_flows;
193         t->result = EVT_TEST_FAILED;
194         t->opt = opt;
195         return 0;
196
197 exp_nomem:
198         rte_free(t->producer_flow_seq);
199 prod_nomem:
200         rte_free(test->test_priv);
201 nomem:
202         return -ENOMEM;
203 }
204
205 void
206 order_test_destroy(struct evt_test *test, struct evt_options *opt)
207 {
208         RTE_SET_USED(opt);
209         struct test_order *t = evt_test_priv(test);
210
211         rte_free(t->expected_flow_seq);
212         rte_free(t->producer_flow_seq);
213         rte_free(test->test_priv);
214 }
215
216 int
217 order_mempool_setup(struct evt_test *test, struct evt_options *opt)
218 {
219         struct test_order *t = evt_test_priv(test);
220
221         t->pool  = rte_pktmbuf_pool_create(test->name, opt->pool_sz,
222                                         256 /* Cache */, 0,
223                                         512, /* Use very small mbufs */
224                                         opt->socket_id);
225         if (t->pool == NULL) {
226                 evt_err("failed to create mempool");
227                 return -ENOMEM;
228         }
229
230         return 0;
231 }
232
233 void
234 order_mempool_destroy(struct evt_test *test, struct evt_options *opt)
235 {
236         RTE_SET_USED(opt);
237         struct test_order *t = evt_test_priv(test);
238
239         rte_mempool_free(t->pool);
240 }
241
242 void
243 order_eventdev_destroy(struct evt_test *test, struct evt_options *opt)
244 {
245         RTE_SET_USED(test);
246
247         rte_event_dev_stop(opt->dev_id);
248         rte_event_dev_close(opt->dev_id);
249 }
250
251 void
252 order_opt_dump(struct evt_options *opt)
253 {
254         evt_dump_producer_lcores(opt);
255         evt_dump("nb_wrker_lcores", "%d", evt_nr_active_lcores(opt->wlcores));
256         evt_dump_worker_lcores(opt);
257         evt_dump("nb_evdev_ports", "%d", order_nb_event_ports(opt));
258 }
259
260 int
261 order_launch_lcores(struct evt_test *test, struct evt_options *opt,
262                         int (*worker)(void *))
263 {
264         int ret, lcore_id;
265         struct test_order *t = evt_test_priv(test);
266
267         int wkr_idx = 0;
268         /* launch workers */
269         RTE_LCORE_FOREACH_SLAVE(lcore_id) {
270                 if (!(opt->wlcores[lcore_id]))
271                         continue;
272
273                 ret = rte_eal_remote_launch(worker, &t->worker[wkr_idx],
274                                          lcore_id);
275                 if (ret) {
276                         evt_err("failed to launch worker %d", lcore_id);
277                         return ret;
278                 }
279                 wkr_idx++;
280         }
281
282         /* launch producer */
283         int plcore = evt_get_first_active_lcore(opt->plcores);
284
285         ret = rte_eal_remote_launch(order_producer, &t->prod, plcore);
286         if (ret) {
287                 evt_err("failed to launch order_producer %d", plcore);
288                 return ret;
289         }
290
291         uint64_t cycles = rte_get_timer_cycles();
292         int64_t old_remaining  = -1;
293
294         while (t->err == false) {
295                 uint64_t new_cycles = rte_get_timer_cycles();
296                 int64_t remaining = rte_atomic64_read(&t->outstand_pkts);
297
298                 if (remaining <= 0) {
299                         t->result = EVT_TEST_SUCCESS;
300                         break;
301                 }
302
303                 if (new_cycles - cycles > rte_get_timer_hz() * 1) {
304                         printf(CLGRN"\r%"PRId64""CLNRM, remaining);
305                         fflush(stdout);
306                         if (old_remaining == remaining) {
307                                 rte_event_dev_dump(opt->dev_id, stdout);
308                                 evt_err("No schedules for seconds, deadlock");
309                                 t->err = true;
310                                 rte_smp_wmb();
311                                 break;
312                         }
313                         old_remaining = remaining;
314                         cycles = new_cycles;
315                 }
316         }
317         printf("\r");
318
319         return 0;
320 }
321
322 int
323 order_event_dev_port_setup(struct evt_test *test, struct evt_options *opt,
324                                 uint8_t nb_workers, uint8_t nb_queues)
325 {
326         int ret;
327         uint8_t port;
328         struct test_order *t = evt_test_priv(test);
329
330         /* port configuration */
331         const struct rte_event_port_conf wkr_p_conf = {
332                         .dequeue_depth = opt->wkr_deq_dep,
333                         .enqueue_depth = 64,
334                         .new_event_threshold = 4096,
335         };
336
337         /* setup one port per worker, linking to all queues */
338         for (port = 0; port < nb_workers; port++) {
339                 struct worker_data *w = &t->worker[port];
340
341                 w->dev_id = opt->dev_id;
342                 w->port_id = port;
343                 w->t = t;
344
345                 ret = rte_event_port_setup(opt->dev_id, port, &wkr_p_conf);
346                 if (ret) {
347                         evt_err("failed to setup port %d", port);
348                         return ret;
349                 }
350
351                 ret = rte_event_port_link(opt->dev_id, port, NULL, NULL, 0);
352                 if (ret != nb_queues) {
353                         evt_err("failed to link all queues to port %d", port);
354                         return -EINVAL;
355                 }
356         }
357         /* port for producer, no links */
358         const struct rte_event_port_conf prod_conf = {
359                         .dequeue_depth = 8,
360                         .enqueue_depth = 32,
361                         .new_event_threshold = 1200,
362         };
363         struct prod_data *p = &t->prod;
364
365         p->dev_id = opt->dev_id;
366         p->port_id = port; /* last port */
367         p->queue_id = 0;
368         p->t = t;
369
370         ret = rte_event_port_setup(opt->dev_id, port, &prod_conf);
371         if (ret) {
372                 evt_err("failed to setup producer port %d", port);
373                 return ret;
374         }
375
376         return ret;
377 }