2 * Copyright (c) 2016-2018 Netflix, Inc.
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
7 * 1. Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * 2. Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
13 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
14 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
16 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
17 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
18 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
19 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
20 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
21 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
22 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28 #ifndef __tcp_hpts_h__
29 #define __tcp_hpts_h__
32 * The hpts uses a 102400 wheel. The wheel
33 * defines the time in 10 usec increments (102400 x 10).
34 * This gives a range of 10usec - 1024ms to place
35 * an entry within. If the user requests more than
36 * 1.024 second, a remaineder is attached and the hpts
37 * when seeing the remainder will re-insert the
38 * inpcb forward in time from where it is until
39 * the remainder is zero.
42 #define NUM_OF_HPTSI_SLOTS 102400
44 TAILQ_HEAD(hptsh, inpcb);
46 /* Number of useconds in a hpts tick */
47 #define HPTS_TICKS_PER_SLOT 10
48 #define HPTS_MS_TO_SLOTS(x) ((x * 100) + 1)
49 #define HPTS_USEC_TO_SLOTS(x) ((x+9) /10)
50 #define HPTS_USEC_IN_SEC 1000000
51 #define HPTS_MSEC_IN_SEC 1000
52 #define HPTS_USEC_IN_MSEC 1000
55 uint32_t p_hpts_active; /* bbr->flex7 x */
56 uint32_t p_nxt_slot; /* bbr->flex1 x */
57 uint32_t p_cur_slot; /* bbr->flex2 x */
58 uint32_t p_prev_slot; /* bbr->delivered */
59 uint32_t p_runningslot; /* bbr->inflight */
60 uint32_t slot_req; /* bbr->flex3 x */
61 uint32_t inp_hptsslot; /* bbr->flex4 x */
62 uint32_t slot_remaining; /* bbr->flex5 x */
63 uint32_t have_slept; /* bbr->epoch x */
64 uint32_t hpts_sleep_time; /* bbr->applimited x */
65 uint32_t yet_to_sleep; /* bbr->lt_epoch x */
66 uint32_t need_new_to; /* bbr->flex6 x */
67 uint32_t wheel_slot; /* bbr->bw_inuse x */
68 uint32_t maxslots; /* bbr->delRate x */
69 uint32_t wheel_cts; /* bbr->rttProp x */
70 int32_t co_ret; /* bbr->pkts_out x */
71 uint32_t p_curtick; /* upper bbr->cur_del_rate */
72 uint32_t p_lasttick; /* lower bbr->cur_del_rate */
73 uint8_t p_on_min_sleep; /* bbr->flex8 x */
76 /* Magic flags to tell whats cooking on the pacing wheel */
77 #define PACE_TMR_DELACK 0x01 /* Delayed ack timer running */
78 #define PACE_TMR_RACK 0x02 /* RACK timer running */
79 #define PACE_TMR_TLP 0x04 /* TLP timer running */
80 #define PACE_TMR_RXT 0x08 /* Retransmit timer running */
81 #define PACE_TMR_PERSIT 0x10 /* Persists timer running */
82 #define PACE_TMR_KEEP 0x20 /* Keep alive timer running */
83 #define PACE_PKT_OUTPUT 0x40 /* Output Packets being paced */
84 #define PACE_TMR_MASK (PACE_TMR_KEEP|PACE_TMR_PERSIT|PACE_TMR_RXT|PACE_TMR_TLP|PACE_TMR_RACK|PACE_TMR_DELACK)
86 #define DEFAULT_CONNECTION_THESHOLD 100
89 /* Each hpts has its own p_mtx which is used for locking */
90 struct tcp_hpts_entry {
92 struct mtx p_mtx; /* Mutex for hpts */
93 struct timeval p_mysleep; /* Our min sleep time */
95 uint64_t sleeping; /* What the actual sleep was (if sleeping) */
96 uint16_t p_hpts_active; /* Flag that says hpts is awake */
97 uint8_t p_wheel_complete; /* have we completed the wheel arc walk? */
98 uint32_t p_curtick; /* Tick in 10 us the hpts is going to */
99 uint32_t p_runningslot; /* Current tick we are at if we are running */
100 uint32_t p_prev_slot; /* Previous slot we were on */
101 uint32_t p_cur_slot; /* Current slot in wheel hpts is draining */
102 uint32_t p_nxt_slot; /* The next slot outside the current range of
103 * slots that the hpts is running on. */
104 int32_t p_on_queue_cnt; /* Count on queue in this hpts */
105 uint32_t p_lasttick; /* Last tick before the current one */
106 uint8_t p_direct_wake :1, /* boolean */
107 p_on_min_sleep:1, /* boolean */
108 p_hpts_wake_scheduled:1, /* boolean */
110 uint8_t p_fill[3]; /* Fill to 32 bits */
111 /* Cache line 0x40 */
113 struct hptsh p_input; /* For the tcp-input runner */
115 struct hptsh *p_hptss;
116 int32_t p_on_inqueue_cnt; /* Count on input queue in this hpts */
117 uint32_t p_hpts_sleep_time; /* Current sleep interval having a max
119 uint32_t overidden_sleep; /* what was overrided by min-sleep for logging */
120 uint32_t saved_lasttick; /* for logging */
121 uint32_t saved_curtick; /* for logging */
122 uint32_t saved_curslot; /* for logging */
123 uint32_t saved_prev_slot; /* for logging */
124 uint32_t p_delayed_by; /* How much were we delayed by */
125 /* Cache line 0x80 */
126 struct sysctl_ctx_list hpts_ctx;
127 struct sysctl_oid *hpts_root;
128 struct intr_event *ie;
130 uint16_t p_num; /* The hpts number one per cpu */
131 uint16_t p_cpu; /* The hpts CPU */
132 /* There is extra space in here */
133 /* Cache line 0x100 */
134 struct callout co __aligned(CACHE_LINE_SIZE);
135 } __aligned(CACHE_LINE_SIZE);
138 struct proc *rp_proc; /* Process structure for hpts */
139 struct tcp_hpts_entry **rp_ent; /* Array of hptss */
140 uint32_t *cts_last_ran;
141 uint32_t rp_num_hptss; /* Number of hpts threads */
146 #define HPTS_REMOVE_INPUT 0x01
147 #define HPTS_REMOVE_OUTPUT 0x02
148 #define HPTS_REMOVE_ALL (HPTS_REMOVE_INPUT | HPTS_REMOVE_OUTPUT)
151 * When using the hpts, a TCP stack must make sure
152 * that once a INP_DROPPED flag is applied to a INP
153 * that it does not expect tcp_output() to ever be
154 * called by the hpts. The hpts will *not* call
155 * any output (or input) functions on a TCB that
156 * is in the DROPPED state.
158 * This implies final ACK's and RST's that might
159 * be sent when a TCB is still around must be
160 * sent from a routine like tcp_respond().
162 #define LOWEST_SLEEP_ALLOWED 50
163 #define DEFAULT_MIN_SLEEP 250 /* How many usec's is default for hpts sleep
164 * this determines min granularity of the
165 * hpts. If 1, granularity is 10useconds at
166 * the cost of more CPU (context switching).
167 * Note do not set this to 0.
169 #define DYNAMIC_MIN_SLEEP DEFAULT_MIN_SLEEP
170 #define DYNAMIC_MAX_SLEEP 100000 /* 100ms */
171 /* No of connections when wee start aligning to the cpu from syscalls */
172 #define OLDEST_THRESHOLD 1200
173 /* Thresholds for raising/lowering sleep */
174 #define TICKS_INDICATE_MORE_SLEEP 100 /* This would be 1ms */
175 #define TICKS_INDICATE_LESS_SLEEP 1000 /* This would indicate 10ms */
178 * Dynamic adjustment of sleeping times is done in "new" mode
179 * where we are depending on syscall returns and lro returns
180 * to push hpts forward mainly and the timer is only a backstop.
182 * When we are in the "new" mode i.e. conn_cnt > conn_cnt_thresh
183 * then we do a dynamic adjustment on the time we sleep.
184 * Our threshold is if the lateness of the first client served (in ticks) is
185 * greater than or equal too ticks_indicate_more_sleep (10ms
186 * or 10000 ticks). If we were that late, the actual sleep time
187 * is adjusted down by 50%. If the ticks_ran is less than
188 * ticks_indicate_more_sleep (100 ticks or 1000usecs).
194 #define HPTS_MTX_ASSERT(hpts) mtx_assert(&(hpts)->p_mtx, MA_OWNED)
195 struct tcp_hpts_entry *tcp_hpts_lock(struct inpcb *inp);
196 struct tcp_hpts_entry *tcp_input_lock(struct inpcb *inp);
197 int __tcp_queue_to_hpts_immediate(struct inpcb *inp, int32_t line);
198 #define tcp_queue_to_hpts_immediate(a)__tcp_queue_to_hpts_immediate(a, __LINE__)
200 struct tcp_hpts_entry *tcp_cur_hpts(struct inpcb *inp);
201 #define tcp_hpts_remove(a, b) __tcp_hpts_remove(a, b, __LINE__)
202 void __tcp_hpts_remove(struct inpcb *inp, int32_t flags, int32_t line);
205 * To insert a TCB on the hpts you *must* be holding the
206 * INP_WLOCK(). The hpts insert code will then acqurire
207 * the hpts's lock and insert the TCB on the requested
208 * slot possibly waking up the hpts if you are requesting
209 * a time earlier than what the hpts is sleeping to (if
210 * the hpts is sleeping). You may check the inp->inp_in_hpts
211 * flag without the hpts lock. The hpts is the only one
212 * that will clear this flag holding only the hpts lock. This
213 * means that in your tcp_output() routine when you test for
214 * it to be 1 (so you wont call output) it may be transitioning
215 * to 0 (by the hpts). That will be fine since that will just
216 * mean an extra call to tcp_output that most likely will find
217 * the call you executed (when the mis-match occurred) will have
218 * put the TCB back on the hpts and it will return. If your
219 * call did not add it back to the hpts then you will either
220 * over-send or the cwnd will block you from sending more.
222 * Note you should also be holding the INP_WLOCK() when you
223 * call the remove from the hpts as well. Thoug usually
224 * you are either doing this from a timer, where you need
225 * that INP_WLOCK() or from destroying your TCB where again
226 * you should already have the INP_WLOCK().
228 uint32_t __tcp_hpts_insert(struct inpcb *inp, uint32_t slot, int32_t line);
229 #define tcp_hpts_insert(a, b) __tcp_hpts_insert(a, b, __LINE__)
232 tcp_hpts_insert_diag(struct inpcb *inp, uint32_t slot, int32_t line, struct hpts_diag *diag);
235 __tcp_queue_to_input_locked(struct inpcb *inp, struct tcp_hpts_entry *hpts, int32_t line);
236 #define tcp_queue_to_input_locked(a, b) __tcp_queue_to_input_locked(a, b, __LINE__);
238 __tcp_queue_to_input(struct inpcb *inp, int32_t line);
239 #define tcp_queue_to_input(a) __tcp_queue_to_input(a, __LINE__)
241 uint16_t tcp_hpts_delayedby(struct inpcb *inp);
243 void __tcp_set_hpts(struct inpcb *inp, int32_t line);
244 #define tcp_set_hpts(a) __tcp_set_hpts(a, __LINE__)
246 void __tcp_set_inp_to_drop(struct inpcb *inp, uint16_t reason, int32_t line);
247 #define tcp_set_inp_to_drop(a, b) __tcp_set_inp_to_drop(a, b, __LINE__)
249 void tcp_run_hpts(void);
251 uint16_t hpts_random_cpu(struct inpcb *inp);
253 extern int32_t tcp_min_hptsi_time;
258 * The following functions should also be available
259 * to userspace as well.
261 static __inline uint32_t
262 tcp_tv_to_hptstick(const struct timeval *sv)
264 return ((sv->tv_sec * 100000) + (sv->tv_usec / HPTS_TICKS_PER_SLOT));
267 static __inline uint32_t
268 tcp_tv_to_usectick(const struct timeval *sv)
270 return ((uint32_t) ((sv->tv_sec * HPTS_USEC_IN_SEC) + sv->tv_usec));
273 static __inline uint32_t
274 tcp_tv_to_mssectick(const struct timeval *sv)
276 return ((uint32_t) ((sv->tv_sec * HPTS_MSEC_IN_SEC) + (sv->tv_usec/HPTS_USEC_IN_MSEC)));
279 static __inline uint64_t
280 tcp_tv_to_lusectick(const struct timeval *sv)
282 return ((uint64_t)((sv->tv_sec * HPTS_USEC_IN_SEC) + sv->tv_usec));
288 tcp_hpts_unlock(struct tcp_hpts_entry *hpts)
290 mtx_unlock(&hpts->p_mtx);
293 static __inline uint32_t
294 tcp_gethptstick(struct timeval *sv)
301 return (tcp_tv_to_hptstick(sv));
304 static __inline uint32_t
305 tcp_get_usecs(struct timeval *tv)
312 return (tcp_tv_to_usectick(tv));
316 #endif /* __tcp_hpts_h__ */