net/ice: fix Tx threshold setup
[dpdk.git] / drivers / event / dsw / dsw_evdev.h
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2018 Ericsson AB
3  */
4
5 #ifndef _DSW_EVDEV_H_
6 #define _DSW_EVDEV_H_
7
8 #include <rte_event_ring.h>
9 #include <rte_eventdev.h>
10
11 #define DSW_PMD_NAME RTE_STR(event_dsw)
12
13 /* Code changes are required to allow more ports. */
14 #define DSW_MAX_PORTS (64)
15 #define DSW_MAX_PORT_DEQUEUE_DEPTH (128)
16 #define DSW_MAX_PORT_ENQUEUE_DEPTH (128)
17 #define DSW_MAX_PORT_OUT_BUFFER (32)
18
19 #define DSW_MAX_QUEUES (16)
20
21 #define DSW_MAX_EVENTS (16384)
22
23 /* Code changes are required to allow more flows than 32k. */
24 #define DSW_MAX_FLOWS_BITS (15)
25 #define DSW_MAX_FLOWS (1<<(DSW_MAX_FLOWS_BITS))
26 #define DSW_MAX_FLOWS_MASK (DSW_MAX_FLOWS-1)
27
28 /* Eventdev RTE_SCHED_TYPE_PARALLEL doesn't have a concept of flows,
29  * but the 'dsw' scheduler (more or less) randomly assign flow id to
30  * events on parallel queues, to be able to reuse some of the
31  * migration mechanism and scheduling logic from
32  * RTE_SCHED_TYPE_ATOMIC. By moving one of the parallel "flows" from a
33  * particular port, the likely-hood of events being scheduled to this
34  * port is reduced, and thus a kind of statistical load balancing is
35  * achieved.
36  */
37 #define DSW_PARALLEL_FLOWS (1024)
38
39 /* 'Background tasks' are polling the control rings for *
40  *  migration-related messages, or flush the output buffer (so
41  *  buffered events doesn't linger too long). Shouldn't be too low,
42  *  since the system won't benefit from the 'batching' effects from
43  *  the output buffer, and shouldn't be too high, since it will make
44  *  buffered events linger too long in case the port goes idle.
45  */
46 #define DSW_MAX_PORT_OPS_PER_BG_TASK (128)
47
48 /* Avoid making small 'loans' from the central in-flight event credit
49  * pool, to improve efficiency.
50  */
51 #define DSW_MIN_CREDIT_LOAN (64)
52 #define DSW_PORT_MAX_CREDITS (2*DSW_MIN_CREDIT_LOAN)
53 #define DSW_PORT_MIN_CREDITS (DSW_MIN_CREDIT_LOAN)
54
55 /* The rings are dimensioned so that all in-flight events can reside
56  * on any one of the port rings, to avoid the trouble of having to
57  * care about the case where there's no room on the destination port's
58  * input ring.
59  */
60 #define DSW_IN_RING_SIZE (DSW_MAX_EVENTS)
61
62 #define DSW_MAX_LOAD (INT16_MAX)
63 #define DSW_LOAD_FROM_PERCENT(x) ((int16_t)(((x)*DSW_MAX_LOAD)/100))
64 #define DSW_LOAD_TO_PERCENT(x) ((100*x)/DSW_MAX_LOAD)
65
66 /* The thought behind keeping the load update interval shorter than
67  * the migration interval is that the load from newly migrated flows
68  * should 'show up' on the load measurement before new migrations are
69  * considered. This is to avoid having too many flows, from too many
70  * source ports, to be migrated too quickly to a lightly loaded port -
71  * in particular since this might cause the system to oscillate.
72  */
73 #define DSW_LOAD_UPDATE_INTERVAL (DSW_MIGRATION_INTERVAL/4)
74 #define DSW_OLD_LOAD_WEIGHT (1)
75
76 /* The minimum time (in us) between two flow migrations. What puts an
77  * upper limit on the actual migration rate is primarily the pace in
78  * which the ports send and receive control messages, which in turn is
79  * largely a function of how much cycles are spent the processing of
80  * an event burst.
81  */
82 #define DSW_MIGRATION_INTERVAL (1000)
83 #define DSW_MIN_SOURCE_LOAD_FOR_MIGRATION (DSW_LOAD_FROM_PERCENT(70))
84 #define DSW_MAX_TARGET_LOAD_FOR_MIGRATION (DSW_LOAD_FROM_PERCENT(95))
85
86 #define DSW_MAX_EVENTS_RECORDED (128)
87
88 /* Only one outstanding migration per port is allowed */
89 #define DSW_MAX_PAUSED_FLOWS (DSW_MAX_PORTS)
90
91 /* Enough room for paus request/confirm and unpaus request/confirm for
92  * all possible senders.
93  */
94 #define DSW_CTL_IN_RING_SIZE ((DSW_MAX_PORTS-1)*4)
95
96 /* With DSW_SORT_DEQUEUED enabled, the scheduler will, at the point of
97  * dequeue(), arrange events so that events with the same flow id on
98  * the same queue forms a back-to-back "burst", and also so that such
99  * bursts of different flow ids, but on the same queue, also come
100  * consecutively. All this in an attempt to improve data and
101  * instruction cache usage for the application, at the cost of a
102  * scheduler overhead increase.
103  */
104
105 /* #define DSW_SORT_DEQUEUED */
106
107 struct dsw_queue_flow {
108         uint8_t queue_id;
109         uint16_t flow_hash;
110 };
111
112 enum dsw_migration_state {
113         DSW_MIGRATION_STATE_IDLE,
114         DSW_MIGRATION_STATE_PAUSING,
115         DSW_MIGRATION_STATE_FORWARDING,
116         DSW_MIGRATION_STATE_UNPAUSING
117 };
118
119 struct dsw_port {
120         uint16_t id;
121
122         /* Keeping a pointer here to avoid container_of() calls, which
123          * are expensive since they are very frequent and will result
124          * in an integer multiplication (since the port id is an index
125          * into the dsw_evdev port array).
126          */
127         struct dsw_evdev *dsw;
128
129         uint16_t dequeue_depth;
130         uint16_t enqueue_depth;
131
132         int32_t inflight_credits;
133
134         int32_t new_event_threshold;
135
136         uint16_t pending_releases;
137
138         uint16_t next_parallel_flow_id;
139
140         uint16_t ops_since_bg_task;
141
142         /* most recent 'background' processing */
143         uint64_t last_bg;
144
145         /* For port load measurement. */
146         uint64_t next_load_update;
147         uint64_t load_update_interval;
148         uint64_t measurement_start;
149         uint64_t busy_start;
150         uint64_t busy_cycles;
151         uint64_t total_busy_cycles;
152
153         /* For the ctl interface and flow migration mechanism. */
154         uint64_t next_migration;
155         uint64_t migration_interval;
156         enum dsw_migration_state migration_state;
157
158         uint64_t migration_start;
159         uint64_t migrations;
160         uint64_t migration_latency;
161
162         uint8_t migration_target_port_id;
163         struct dsw_queue_flow migration_target_qf;
164         uint8_t cfm_cnt;
165
166         uint16_t paused_flows_len;
167         struct dsw_queue_flow paused_flows[DSW_MAX_PAUSED_FLOWS];
168
169         /* In a very contrived worst case all inflight events can be
170          * laying around paused here.
171          */
172         uint16_t paused_events_len;
173         struct rte_event paused_events[DSW_MAX_EVENTS];
174
175         uint16_t seen_events_len;
176         uint16_t seen_events_idx;
177         struct dsw_queue_flow seen_events[DSW_MAX_EVENTS_RECORDED];
178
179         uint64_t new_enqueued;
180         uint64_t forward_enqueued;
181         uint64_t release_enqueued;
182         uint64_t queue_enqueued[DSW_MAX_QUEUES];
183
184         uint64_t dequeued;
185         uint64_t queue_dequeued[DSW_MAX_QUEUES];
186
187         uint16_t out_buffer_len[DSW_MAX_PORTS];
188         struct rte_event out_buffer[DSW_MAX_PORTS][DSW_MAX_PORT_OUT_BUFFER];
189
190         uint16_t in_buffer_len;
191         uint16_t in_buffer_start;
192         /* This buffer may contain events that were read up from the
193          * in_ring during the flow migration process.
194          */
195         struct rte_event in_buffer[DSW_MAX_EVENTS];
196
197         struct rte_event_ring *in_ring __rte_cache_aligned;
198
199         struct rte_ring *ctl_in_ring __rte_cache_aligned;
200
201         /* Estimate of current port load. */
202         rte_atomic16_t load __rte_cache_aligned;
203 } __rte_cache_aligned;
204
205 struct dsw_queue {
206         uint8_t schedule_type;
207         uint8_t serving_ports[DSW_MAX_PORTS];
208         uint16_t num_serving_ports;
209
210         uint8_t flow_to_port_map[DSW_MAX_FLOWS] __rte_cache_aligned;
211 };
212
213 struct dsw_evdev {
214         struct rte_eventdev_data *data;
215
216         struct dsw_port ports[DSW_MAX_PORTS];
217         uint16_t num_ports;
218         struct dsw_queue queues[DSW_MAX_QUEUES];
219         uint8_t num_queues;
220         int32_t max_inflight;
221
222         rte_atomic32_t credits_on_loan __rte_cache_aligned;
223 };
224
225 #define DSW_CTL_PAUS_REQ (0)
226 #define DSW_CTL_UNPAUS_REQ (1)
227 #define DSW_CTL_CFM (2)
228
229 /* sizeof(struct dsw_ctl_msg) must be equal or less than
230  * sizeof(void *), to fit on the control ring.
231  */
232 struct dsw_ctl_msg {
233         uint8_t type:2;
234         uint8_t originating_port_id:6;
235         uint8_t queue_id;
236         uint16_t flow_hash;
237 } __rte_packed;
238
239 uint16_t dsw_event_enqueue(void *port, const struct rte_event *event);
240 uint16_t dsw_event_enqueue_burst(void *port,
241                                  const struct rte_event events[],
242                                  uint16_t events_len);
243 uint16_t dsw_event_enqueue_new_burst(void *port,
244                                      const struct rte_event events[],
245                                      uint16_t events_len);
246 uint16_t dsw_event_enqueue_forward_burst(void *port,
247                                          const struct rte_event events[],
248                                          uint16_t events_len);
249
250 uint16_t dsw_event_dequeue(void *port, struct rte_event *ev, uint64_t wait);
251 uint16_t dsw_event_dequeue_burst(void *port, struct rte_event *events,
252                                  uint16_t num, uint64_t wait);
253
254 int dsw_xstats_get_names(const struct rte_eventdev *dev,
255                          enum rte_event_dev_xstats_mode mode,
256                          uint8_t queue_port_id,
257                          struct rte_event_dev_xstats_name *xstats_names,
258                          unsigned int *ids, unsigned int size);
259 int dsw_xstats_get(const struct rte_eventdev *dev,
260                    enum rte_event_dev_xstats_mode mode, uint8_t queue_port_id,
261                    const unsigned int ids[], uint64_t values[], unsigned int n);
262 uint64_t dsw_xstats_get_by_name(const struct rte_eventdev *dev,
263                                 const char *name, unsigned int *id);
264
265 static inline struct dsw_evdev *
266 dsw_pmd_priv(const struct rte_eventdev *eventdev)
267 {
268         return eventdev->data->dev_private;
269 }
270
271 #define DSW_LOG_DP(level, fmt, args...)                                 \
272         RTE_LOG_DP(level, EVENTDEV, "[%s] %s() line %u: " fmt,          \
273                    DSW_PMD_NAME,                                        \
274                    __func__, __LINE__, ## args)
275
276 #define DSW_LOG_DP_PORT(level, port_id, fmt, args...)           \
277         DSW_LOG_DP(level, "<Port %d> " fmt, port_id, ## args)
278
279 #endif