projects / openwrt / staging / hauke.git / blob
? search:


c9196435052f7d9d3900030974eeda773d3abf89
[openwrt/staging/hauke.git] /
1 From: Felix Fietkau <nbd@nbd.name>
2 Date: Tue, 8 Oct 2019 18:54:46 +0200
3 Subject: [PATCH] mac80211: minstrel_ht: rename prob_ewma to prob_avg, use it
4 for the new average
5
6 Reduces per-rate data structure size
7
8 Signed-off-by: Felix Fietkau <nbd@nbd.name>
9 ---
10
11 --- a/net/mac80211/rc80211_minstrel.c
12 +++ b/net/mac80211/rc80211_minstrel.c
13 @@ -70,7 +70,7 @@ rix_to_ndx(struct minstrel_sta_info *mi,
14 }
15
16 /* return current EMWA throughput */
17 -int minstrel_get_tp_avg(struct minstrel_rate *mr, int prob_ewma)
18 +int minstrel_get_tp_avg(struct minstrel_rate *mr, int prob_avg)
19 {
20 int usecs;
21
22 @@ -79,13 +79,13 @@ int minstrel_get_tp_avg(struct minstrel_
23 usecs = 1000000;
24
25 /* reset thr. below 10% success */
26 - if (mr->stats.prob_ewma < MINSTREL_FRAC(10, 100))
27 + if (mr->stats.prob_avg < MINSTREL_FRAC(10, 100))
28 return 0;
29
30 - if (prob_ewma > MINSTREL_FRAC(90, 100))
31 + if (prob_avg > MINSTREL_FRAC(90, 100))
32 return MINSTREL_TRUNC(100000 * (MINSTREL_FRAC(90, 100) / usecs));
33 else
34 - return MINSTREL_TRUNC(100000 * (prob_ewma / usecs));
35 + return MINSTREL_TRUNC(100000 * (prob_avg / usecs));
36 }
37
38 /* find & sort topmost throughput rates */
39 @@ -98,8 +98,8 @@ minstrel_sort_best_tp_rates(struct minst
40
41 for (j = MAX_THR_RATES; j > 0; --j) {
42 tmp_mrs = &mi->r[tp_list[j - 1]].stats;
43 - if (minstrel_get_tp_avg(&mi->r[i], cur_mrs->prob_ewma) <=
44 - minstrel_get_tp_avg(&mi->r[tp_list[j - 1]], tmp_mrs->prob_ewma))
45 + if (minstrel_get_tp_avg(&mi->r[i], cur_mrs->prob_avg) <=
46 + minstrel_get_tp_avg(&mi->r[tp_list[j - 1]], tmp_mrs->prob_avg))
47 break;
48 }
49
50 @@ -166,21 +166,21 @@ minstrel_calc_rate_stats(struct minstrel
51 mrs->sample_skipped = 0;
52 cur_prob = MINSTREL_FRAC(mrs->success, mrs->attempts);
53 if (mp->new_avg) {
54 - mrs->prob_ewma = minstrel_filter_avg_add(&mrs->avg,
55 - cur_prob);
56 + minstrel_filter_avg_add(&mrs->prob_avg,
57 + &mrs->prob_avg_1, cur_prob);
58 } else if (unlikely(!mrs->att_hist)) {
59 - mrs->prob_ewma = cur_prob;
60 + mrs->prob_avg = cur_prob;
61 } else {
62 /* update exponential weighted moving variance */
63 mrs->prob_ewmv = minstrel_ewmv(mrs->prob_ewmv,
64 cur_prob,
65 - mrs->prob_ewma,
66 + mrs->prob_avg,
67 EWMA_LEVEL);
68
69 /*update exponential weighted moving avarage */
70 - mrs->prob_ewma = minstrel_ewma(mrs->prob_ewma,
71 - cur_prob,
72 - EWMA_LEVEL);
73 + mrs->prob_avg = minstrel_ewma(mrs->prob_avg,
74 + cur_prob,
75 + EWMA_LEVEL);
76 }
77 mrs->att_hist += mrs->attempts;
78 mrs->succ_hist += mrs->success;
79 @@ -214,8 +214,8 @@ minstrel_update_stats(struct minstrel_pr
80
81 /* Sample less often below the 10% chance of success.
82 * Sample less often above the 95% chance of success. */
83 - if (mrs->prob_ewma > MINSTREL_FRAC(95, 100) ||
84 - mrs->prob_ewma < MINSTREL_FRAC(10, 100)) {
85 + if (mrs->prob_avg > MINSTREL_FRAC(95, 100) ||
86 + mrs->prob_avg < MINSTREL_FRAC(10, 100)) {
87 mr->adjusted_retry_count = mrs->retry_count >> 1;
88 if (mr->adjusted_retry_count > 2)
89 mr->adjusted_retry_count = 2;
90 @@ -235,14 +235,14 @@ minstrel_update_stats(struct minstrel_pr
91 * choose the maximum throughput rate as max_prob_rate
92 * (2) if all success probabilities < 95%, the rate with
93 * highest success probability is chosen as max_prob_rate */
94 - if (mrs->prob_ewma >= MINSTREL_FRAC(95, 100)) {
95 - tmp_cur_tp = minstrel_get_tp_avg(mr, mrs->prob_ewma);
96 + if (mrs->prob_avg >= MINSTREL_FRAC(95, 100)) {
97 + tmp_cur_tp = minstrel_get_tp_avg(mr, mrs->prob_avg);
98 tmp_prob_tp = minstrel_get_tp_avg(&mi->r[tmp_prob_rate],
99 - tmp_mrs->prob_ewma);
100 + tmp_mrs->prob_avg);
101 if (tmp_cur_tp >= tmp_prob_tp)
102 tmp_prob_rate = i;
103 } else {
104 - if (mrs->prob_ewma >= tmp_mrs->prob_ewma)
105 + if (mrs->prob_avg >= tmp_mrs->prob_avg)
106 tmp_prob_rate = i;
107 }
108 }
109 @@ -436,7 +436,7 @@ minstrel_get_rate(void *priv, struct iee
110 * has a probability of >95%, we shouldn't be attempting
111 * to use it, as this only wastes precious airtime */
112 if (!mrr_capable &&
113 - (mi->r[ndx].stats.prob_ewma > MINSTREL_FRAC(95, 100)))
114 + (mi->r[ndx].stats.prob_avg > MINSTREL_FRAC(95, 100)))
115 return;
116
117 mi->prev_sample = true;
118 @@ -587,7 +587,7 @@ static u32 minstrel_get_expected_through
119 * computing cur_tp
120 */
121 tmp_mrs = &mi->r[idx].stats;
122 - tmp_cur_tp = minstrel_get_tp_avg(&mi->r[idx], tmp_mrs->prob_ewma) * 10;
123 + tmp_cur_tp = minstrel_get_tp_avg(&mi->r[idx], tmp_mrs->prob_avg) * 10;
124 tmp_cur_tp = tmp_cur_tp * 1200 * 8 / 1024;
125
126 return tmp_cur_tp;
127 --- a/net/mac80211/rc80211_minstrel.h
128 +++ b/net/mac80211/rc80211_minstrel.h
129 @@ -63,14 +63,10 @@ minstrel_ewmv(int old_ewmv, int cur_prob
130 return weight * (old_ewmv + MINSTREL_TRUNC(diff * incr)) / EWMA_DIV;
131 }
132
133 -struct minstrel_avg_ctx {
134 - s32 prev[2];
135 -};
136 -
137 -static inline int minstrel_filter_avg_add(struct minstrel_avg_ctx *ctx, s32 in)
138 +static inline int minstrel_filter_avg_add(u16 *prev_1, u16 *prev_2, s32 in)
139 {
140 - s32 out_1 = ctx->prev[0];
141 - s32 out_2 = ctx->prev[1];
142 + s32 out_1 = *prev_1;
143 + s32 out_2 = *prev_2;
144 s32 val;
145
146 if (!in)
147 @@ -92,8 +88,8 @@ static inline int minstrel_filter_avg_ad
148 val = 1;
149
150 out:
151 - ctx->prev[1] = out_1;
152 - ctx->prev[0] = val;
153 + *prev_2 = out_1;
154 + *prev_1 = val;
155
156 return val;
157 }
158 @@ -106,14 +102,15 @@ struct minstrel_rate_stats {
159 /* total attempts/success counters */
160 u32 att_hist, succ_hist;
161
162 - struct minstrel_avg_ctx avg;
163 -
164 /* statistis of packet delivery probability
165 * prob_ewma - exponential weighted moving average of prob
166 * prob_ewmsd - exp. weighted moving standard deviation of prob */
167 - u16 prob_ewma;
168 u16 prob_ewmv;
169
170 + /* prob_avg - moving average of prob */
171 + u16 prob_avg;
172 + u16 prob_avg_1;
173 +
174 /* maximum retry counts */
175 u8 retry_count;
176 u8 retry_count_rtscts;
177 @@ -208,7 +205,7 @@ void minstrel_add_sta_debugfs(void *priv
178 /* Recalculate success probabilities and counters for a given rate using EWMA */
179 void minstrel_calc_rate_stats(struct minstrel_priv *mp,
180 struct minstrel_rate_stats *mrs);
181 -int minstrel_get_tp_avg(struct minstrel_rate *mr, int prob_ewma);
182 +int minstrel_get_tp_avg(struct minstrel_rate *mr, int prob_avg);
183
184 /* debugfs */
185 int minstrel_stats_open(struct inode *inode, struct file *file);
186 --- a/net/mac80211/rc80211_minstrel_debugfs.c
187 +++ b/net/mac80211/rc80211_minstrel_debugfs.c
188 @@ -91,8 +91,9 @@ minstrel_stats_open(struct inode *inode,
189 p += sprintf(p, "%6u ", mr->perfect_tx_time);
190
191 tp_max = minstrel_get_tp_avg(mr, MINSTREL_FRAC(100,100));
192 - tp_avg = minstrel_get_tp_avg(mr, mrs->prob_ewma);
193 - eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000);
194 + tp_avg = minstrel_get_tp_avg(mr, mrs->prob_avg);
195 + eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000);
196 +
197 prob_ewmsd = minstrel_get_ewmsd10(mrs);
198
199 p += sprintf(p, "%4u.%1u %4u.%1u %3u.%1u %3u.%1u"
200 @@ -151,8 +152,8 @@ minstrel_stats_csv_open(struct inode *in
201 p += sprintf(p, "%u,",mr->perfect_tx_time);
202
203 tp_max = minstrel_get_tp_avg(mr, MINSTREL_FRAC(100,100));
204 - tp_avg = minstrel_get_tp_avg(mr, mrs->prob_ewma);
205 - eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000);
206 + tp_avg = minstrel_get_tp_avg(mr, mrs->prob_avg);
207 + eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000);
208 prob_ewmsd = minstrel_get_ewmsd10(mrs);
209
210 p += sprintf(p, "%u.%u,%u.%u,%u.%u,%u.%u,%u,%u,%u,"
211 --- a/net/mac80211/rc80211_minstrel_ht.c
212 +++ b/net/mac80211/rc80211_minstrel_ht.c
213 @@ -313,12 +313,12 @@ minstrel_ht_avg_ampdu_len(struct minstre
214 */
215 int
216 minstrel_ht_get_tp_avg(struct minstrel_ht_sta *mi, int group, int rate,
217 - int prob_ewma)
218 + int prob_avg)
219 {
220 unsigned int nsecs = 0;
221
222 /* do not account throughput if sucess prob is below 10% */
223 - if (prob_ewma < MINSTREL_FRAC(10, 100))
224 + if (prob_avg < MINSTREL_FRAC(10, 100))
225 return 0;
226
227 if (group != MINSTREL_CCK_GROUP)
228 @@ -332,11 +332,11 @@ minstrel_ht_get_tp_avg(struct minstrel_h
229 * account for collision related packet error rate fluctuation
230 * (prob is scaled - see MINSTREL_FRAC above)
231 */
232 - if (prob_ewma > MINSTREL_FRAC(90, 100))
233 + if (prob_avg > MINSTREL_FRAC(90, 100))
234 return MINSTREL_TRUNC(100000 * ((MINSTREL_FRAC(90, 100) * 1000)
235 / nsecs));
236 else
237 - return MINSTREL_TRUNC(100000 * ((prob_ewma * 1000) / nsecs));
238 + return MINSTREL_TRUNC(100000 * ((prob_avg * 1000) / nsecs));
239 }
240
241 /*
242 @@ -356,13 +356,13 @@ minstrel_ht_sort_best_tp_rates(struct mi
243
244 cur_group = index / MCS_GROUP_RATES;
245 cur_idx = index % MCS_GROUP_RATES;
246 - cur_prob = mi->groups[cur_group].rates[cur_idx].prob_ewma;
247 + cur_prob = mi->groups[cur_group].rates[cur_idx].prob_avg;
248 cur_tp_avg = minstrel_ht_get_tp_avg(mi, cur_group, cur_idx, cur_prob);
249
250 do {
251 tmp_group = tp_list[j - 1] / MCS_GROUP_RATES;
252 tmp_idx = tp_list[j - 1] % MCS_GROUP_RATES;
253 - tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_ewma;
254 + tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
255 tmp_tp_avg = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx,
256 tmp_prob);
257 if (cur_tp_avg < tmp_tp_avg ||
258 @@ -399,7 +399,7 @@ minstrel_ht_set_best_prob_rate(struct mi
259
260 tmp_group = mi->max_prob_rate / MCS_GROUP_RATES;
261 tmp_idx = mi->max_prob_rate % MCS_GROUP_RATES;
262 - tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_ewma;
263 + tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
264 tmp_tp_avg = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
265
266 /* if max_tp_rate[0] is from MCS_GROUP max_prob_rate get selected from
267 @@ -411,11 +411,11 @@ minstrel_ht_set_best_prob_rate(struct mi
268
269 max_gpr_group = mg->max_group_prob_rate / MCS_GROUP_RATES;
270 max_gpr_idx = mg->max_group_prob_rate % MCS_GROUP_RATES;
271 - max_gpr_prob = mi->groups[max_gpr_group].rates[max_gpr_idx].prob_ewma;
272 + max_gpr_prob = mi->groups[max_gpr_group].rates[max_gpr_idx].prob_avg;
273
274 - if (mrs->prob_ewma > MINSTREL_FRAC(75, 100)) {
275 + if (mrs->prob_avg > MINSTREL_FRAC(75, 100)) {
276 cur_tp_avg = minstrel_ht_get_tp_avg(mi, cur_group, cur_idx,
277 - mrs->prob_ewma);
278 + mrs->prob_avg);
279 if (cur_tp_avg > tmp_tp_avg)
280 mi->max_prob_rate = index;
281
282 @@ -425,9 +425,9 @@ minstrel_ht_set_best_prob_rate(struct mi
283 if (cur_tp_avg > max_gpr_tp_avg)
284 mg->max_group_prob_rate = index;
285 } else {
286 - if (mrs->prob_ewma > tmp_prob)
287 + if (mrs->prob_avg > tmp_prob)
288 mi->max_prob_rate = index;
289 - if (mrs->prob_ewma > max_gpr_prob)
290 + if (mrs->prob_avg > max_gpr_prob)
291 mg->max_group_prob_rate = index;
292 }
293 }
294 @@ -449,12 +449,12 @@ minstrel_ht_assign_best_tp_rates(struct
295
296 tmp_group = tmp_cck_tp_rate[0] / MCS_GROUP_RATES;
297 tmp_idx = tmp_cck_tp_rate[0] % MCS_GROUP_RATES;
298 - tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_ewma;
299 + tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
300 tmp_cck_tp = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
301
302 tmp_group = tmp_mcs_tp_rate[0] / MCS_GROUP_RATES;
303 tmp_idx = tmp_mcs_tp_rate[0] % MCS_GROUP_RATES;
304 - tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_ewma;
305 + tmp_prob = mi->groups[tmp_group].rates[tmp_idx].prob_avg;
306 tmp_mcs_tp = minstrel_ht_get_tp_avg(mi, tmp_group, tmp_idx, tmp_prob);
307
308 if (tmp_cck_tp_rate && tmp_cck_tp > tmp_mcs_tp) {
309 @@ -485,7 +485,7 @@ minstrel_ht_prob_rate_reduce_streams(str
310 continue;
311
312 tmp_idx = mg->max_group_prob_rate % MCS_GROUP_RATES;
313 - tmp_prob = mi->groups[group].rates[tmp_idx].prob_ewma;
314 + tmp_prob = mi->groups[group].rates[tmp_idx].prob_avg;
315
316 if (tmp_tp < minstrel_ht_get_tp_avg(mi, group, tmp_idx, tmp_prob) &&
317 (minstrel_mcs_groups[group].streams < tmp_max_streams)) {
318 @@ -590,7 +590,7 @@ minstrel_ht_rate_sample_switch(struct mi
319 * If that fails, look again for a rate that is at least as fast
320 */
321 mrs = minstrel_get_ratestats(mi, mi->max_tp_rate[0]);
322 - faster_rate = mrs->prob_ewma > MINSTREL_FRAC(75, 100);
323 + faster_rate = mrs->prob_avg > MINSTREL_FRAC(75, 100);
324 minstrel_ht_find_probe_rates(mi, rates, &n_rates, faster_rate);
325 if (!n_rates && faster_rate)
326 minstrel_ht_find_probe_rates(mi, rates, &n_rates, false);
327 @@ -705,7 +705,7 @@ minstrel_ht_update_stats(struct minstrel
328 mrs = &mg->rates[i];
329 mrs->retry_updated = false;
330 minstrel_calc_rate_stats(mp, mrs);
331 - cur_prob = mrs->prob_ewma;
332 + cur_prob = mrs->prob_avg;
333
334 if (minstrel_ht_get_tp_avg(mi, group, i, cur_prob) == 0)
335 continue;
336 @@ -979,7 +979,7 @@ minstrel_calc_retransmit(struct minstrel
337 unsigned int overhead = 0, overhead_rtscts = 0;
338
339 mrs = minstrel_get_ratestats(mi, index);
340 - if (mrs->prob_ewma < MINSTREL_FRAC(1, 10)) {
341 + if (mrs->prob_avg < MINSTREL_FRAC(1, 10)) {
342 mrs->retry_count = 1;
343 mrs->retry_count_rtscts = 1;
344 return;
345 @@ -1036,7 +1036,7 @@ minstrel_ht_set_rate(struct minstrel_pri
346 if (!mrs->retry_updated)
347 minstrel_calc_retransmit(mp, mi, index);
348
349 - if (mrs->prob_ewma < MINSTREL_FRAC(20, 100) || !mrs->retry_count) {
350 + if (mrs->prob_avg < MINSTREL_FRAC(20, 100) || !mrs->retry_count) {
351 ratetbl->rate[offset].count = 2;
352 ratetbl->rate[offset].count_rts = 2;
353 ratetbl->rate[offset].count_cts = 2;
354 @@ -1070,11 +1070,11 @@ minstrel_ht_set_rate(struct minstrel_pri
355 }
356
357 static inline int
358 -minstrel_ht_get_prob_ewma(struct minstrel_ht_sta *mi, int rate)
359 +minstrel_ht_get_prob_avg(struct minstrel_ht_sta *mi, int rate)
360 {
361 int group = rate / MCS_GROUP_RATES;
362 rate %= MCS_GROUP_RATES;
363 - return mi->groups[group].rates[rate].prob_ewma;
364 + return mi->groups[group].rates[rate].prob_avg;
365 }
366
367 static int
368 @@ -1086,7 +1086,7 @@ minstrel_ht_get_max_amsdu_len(struct min
369 unsigned int duration;
370
371 /* Disable A-MSDU if max_prob_rate is bad */
372 - if (mi->groups[group].rates[rate].prob_ewma < MINSTREL_FRAC(50, 100))
373 + if (mi->groups[group].rates[rate].prob_avg < MINSTREL_FRAC(50, 100))
374 return 1;
375
376 duration = g->duration[rate];
377 @@ -1109,7 +1109,7 @@ minstrel_ht_get_max_amsdu_len(struct min
378 * data packet size
379 */
380 if (duration > MCS_DURATION(1, 0, 260) ||
381 - (minstrel_ht_get_prob_ewma(mi, mi->max_tp_rate[0]) <
382 + (minstrel_ht_get_prob_avg(mi, mi->max_tp_rate[0]) <
383 MINSTREL_FRAC(75, 100)))
384 return 3200;
385
386 @@ -1216,7 +1216,7 @@ minstrel_get_sample_rate(struct minstrel
387 * rate, to avoid wasting airtime.
388 */
389 sample_dur = minstrel_get_duration(sample_idx);
390 - if (mrs->prob_ewma > MINSTREL_FRAC(95, 100) ||
391 + if (mrs->prob_avg > MINSTREL_FRAC(95, 100) ||
392 minstrel_get_duration(mi->max_prob_rate) * 3 < sample_dur)
393 return -1;
394
395 @@ -1679,7 +1679,7 @@ static u32 minstrel_ht_get_expected_thro
396
397 i = mi->max_tp_rate[0] / MCS_GROUP_RATES;
398 j = mi->max_tp_rate[0] % MCS_GROUP_RATES;
399 - prob = mi->groups[i].rates[j].prob_ewma;
400 + prob = mi->groups[i].rates[j].prob_avg;
401
402 /* convert tp_avg from pkt per second in kbps */
403 tp_avg = minstrel_ht_get_tp_avg(mi, i, j, prob) * 10;
404 --- a/net/mac80211/rc80211_minstrel_ht.h
405 +++ b/net/mac80211/rc80211_minstrel_ht.h
406 @@ -122,6 +122,6 @@ struct minstrel_ht_sta_priv {
407
408 void minstrel_ht_add_sta_debugfs(void *priv, void *priv_sta, struct dentry *dir);
409 int minstrel_ht_get_tp_avg(struct minstrel_ht_sta *mi, int group, int rate,
410 - int prob_ewma);
411 + int prob_avg);
412
413 #endif
414 --- a/net/mac80211/rc80211_minstrel_ht_debugfs.c
415 +++ b/net/mac80211/rc80211_minstrel_ht_debugfs.c
416 @@ -102,8 +102,8 @@ minstrel_ht_stats_dump(struct minstrel_h
417 p += sprintf(p, "%6u ", tx_time);
418
419 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100));
420 - tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_ewma);
421 - eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000);
422 + tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_avg);
423 + eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000);
424 prob_ewmsd = minstrel_get_ewmsd10(mrs);
425
426 p += sprintf(p, "%4u.%1u %4u.%1u %3u.%1u %3u.%1u"
427 @@ -250,8 +250,8 @@ minstrel_ht_stats_csv_dump(struct minstr
428 p += sprintf(p, "%u,", tx_time);
429
430 tp_max = minstrel_ht_get_tp_avg(mi, i, j, MINSTREL_FRAC(100, 100));
431 - tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_ewma);
432 - eprob = MINSTREL_TRUNC(mrs->prob_ewma * 1000);
433 + tp_avg = minstrel_ht_get_tp_avg(mi, i, j, mrs->prob_avg);
434 + eprob = MINSTREL_TRUNC(mrs->prob_avg * 1000);
435 prob_ewmsd = minstrel_get_ewmsd10(mrs);
436
437 p += sprintf(p, "%u.%u,%u.%u,%u.%u,%u.%u,%u,%u,"
Hauke Mehrtens staging tree