1 /*- 2 * Copyright (c) 2005 John Bicket 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer, 10 * without modification. 11 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 12 * similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any 13 * redistribution must be conditioned upon including a substantially 14 * similar Disclaimer requirement for further binary redistribution. 15 * 3. Neither the names of the above-listed copyright holders nor the names 16 * of any contributors may be used to endorse or promote products derived 17 * from this software without specific prior written permission. 18 * 19 * Alternatively, this software may be distributed under the terms of the 20 * GNU General Public License ("GPL") version 2 as published by the Free 21 * Software Foundation. 22 * 23 * NO WARRANTY 24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 25 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 26 * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY 27 * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 28 * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, 29 * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER 32 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 34 * THE POSSIBILITY OF SUCH DAMAGES. 35 * 36 */ 37 38 #include <sys/cdefs.h> 39 __FBSDID("$FreeBSD$"); 40 41 /* 42 * John Bicket's SampleRate control algorithm. 43 */ 44 #include "opt_inet.h" 45 #include "opt_wlan.h" 46 47 #include <sys/param.h> 48 #include <sys/systm.h> 49 #include <sys/sysctl.h> 50 #include <sys/kernel.h> 51 #include <sys/lock.h> 52 #include <sys/mutex.h> 53 #include <sys/errno.h> 54 55 #include <machine/bus.h> 56 #include <machine/resource.h> 57 #include <sys/bus.h> 58 59 #include <sys/socket.h> 60 61 #include <net/if.h> 62 #include <net/if_media.h> 63 #include <net/if_arp.h> 64 #include <net/ethernet.h> /* XXX for ether_sprintf */ 65 66 #include <net80211/ieee80211_var.h> 67 68 #include <net/bpf.h> 69 70 #ifdef INET 71 #include <netinet/in.h> 72 #include <netinet/if_ether.h> 73 #endif 74 75 #include <dev/ath/if_athvar.h> 76 #include <dev/ath/ath_rate/sample/sample.h> 77 #include <dev/ath/ath_hal/ah_desc.h> 78 #include <dev/ath/ath_rate/sample/tx_schedules.h> 79 80 /* 81 * This file is an implementation of the SampleRate algorithm 82 * in "Bit-rate Selection in Wireless Networks" 83 * (http://www.pdos.lcs.mit.edu/papers/jbicket-ms.ps) 84 * 85 * SampleRate chooses the bit-rate it predicts will provide the most 86 * throughput based on estimates of the expected per-packet 87 * transmission time for each bit-rate. SampleRate periodically sends 88 * packets at bit-rates other than the current one to estimate when 89 * another bit-rate will provide better performance. SampleRate 90 * switches to another bit-rate when its estimated per-packet 91 * transmission time becomes smaller than the current bit-rate's. 92 * SampleRate reduces the number of bit-rates it must sample by 93 * eliminating those that could not perform better than the one 94 * currently being used. SampleRate also stops probing at a bit-rate 95 * if it experiences several successive losses. 96 * 97 * The difference between the algorithm in the thesis and the one in this 98 * file is that the one in this file uses a ewma instead of a window. 99 * 100 * Also, this implementation tracks the average transmission time for 101 * a few different packet sizes independently for each link. 102 */ 103 104 static void ath_rate_ctl_reset(struct ath_softc *, struct ieee80211_node *); 105 106 static const int packet_size_bins[NUM_PACKET_SIZE_BINS] = { 250, 1600 }; 107 108 static __inline int 109 size_to_bin(int size) 110 { 111 #if NUM_PACKET_SIZE_BINS > 1 112 if (size <= packet_size_bins[0]) 113 return 0; 114 #endif 115 #if NUM_PACKET_SIZE_BINS > 2 116 if (size <= packet_size_bins[1]) 117 return 1; 118 #endif 119 #if NUM_PACKET_SIZE_BINS > 3 120 if (size <= packet_size_bins[2]) 121 return 2; 122 #endif 123 #if NUM_PACKET_SIZE_BINS > 4 124 #error "add support for more packet sizes" 125 #endif 126 return NUM_PACKET_SIZE_BINS-1; 127 } 128 129 static __inline int 130 bin_to_size(int index) 131 { 132 return packet_size_bins[index]; 133 } 134 135 void 136 ath_rate_node_init(struct ath_softc *sc, struct ath_node *an) 137 { 138 /* NB: assumed to be zero'd by caller */ 139 } 140 141 void 142 ath_rate_node_cleanup(struct ath_softc *sc, struct ath_node *an) 143 { 144 } 145 146 static int 147 dot11rate(const HAL_RATE_TABLE *rt, int rix) 148 { 149 return rt->info[rix].phy == IEEE80211_T_HT ? 150 rt->info[rix].dot11Rate : (rt->info[rix].dot11Rate & IEEE80211_RATE_VAL) / 2; 151 } 152 153 static const char * 154 dot11rate_label(const HAL_RATE_TABLE *rt, int rix) 155 { 156 return rt->info[rix].phy == IEEE80211_T_HT ? "MCS" : "Mb "; 157 } 158 159 /* 160 * Return the rix with the lowest average_tx_time, 161 * or -1 if all the average_tx_times are 0. 162 */ 163 static __inline int 164 pick_best_rate(struct sample_node *sn, const HAL_RATE_TABLE *rt, 165 int size_bin, int require_acked_before) 166 { 167 int best_rate_rix, best_rate_tt; 168 uint32_t mask; 169 int rix, tt; 170 171 best_rate_rix = 0; 172 best_rate_tt = 0; 173 for (mask = sn->ratemask, rix = 0; mask != 0; mask >>= 1, rix++) { 174 if ((mask & 1) == 0) /* not a supported rate */ 175 continue; 176 177 tt = sn->stats[size_bin][rix].average_tx_time; 178 if (tt <= 0 || 179 (require_acked_before && 180 !sn->stats[size_bin][rix].packets_acked)) 181 continue; 182 183 /* don't use a bit-rate that has been failing */ 184 if (sn->stats[size_bin][rix].successive_failures > 3) 185 continue; 186 187 if (best_rate_tt == 0 || tt < best_rate_tt) { 188 best_rate_tt = tt; 189 best_rate_rix = rix; 190 } 191 } 192 return (best_rate_tt ? best_rate_rix : -1); 193 } 194 195 /* 196 * Pick a good "random" bit-rate to sample other than the current one. 197 */ 198 static __inline int 199 pick_sample_rate(struct sample_softc *ssc , struct sample_node *sn, 200 const HAL_RATE_TABLE *rt, int size_bin) 201 { 202 #define DOT11RATE(ix) (rt->info[ix].dot11Rate & IEEE80211_RATE_VAL) 203 #define MCS(ix) (rt->info[ix].dot11Rate | IEEE80211_RATE_MCS) 204 int current_rix, rix; 205 unsigned current_tt; 206 uint32_t mask; 207 208 current_rix = sn->current_rix[size_bin]; 209 if (current_rix < 0) { 210 /* no successes yet, send at the lowest bit-rate */ 211 return 0; 212 } 213 214 current_tt = sn->stats[size_bin][current_rix].average_tx_time; 215 216 rix = sn->last_sample_rix[size_bin]+1; /* next sample rate */ 217 mask = sn->ratemask &~ (1<<current_rix);/* don't sample current rate */ 218 while (mask != 0) { 219 if ((mask & (1<<rix)) == 0) { /* not a supported rate */ 220 nextrate: 221 if (++rix >= rt->rateCount) 222 rix = 0; 223 continue; 224 } 225 226 /* this bit-rate is always worse than the current one */ 227 if (sn->stats[size_bin][rix].perfect_tx_time > current_tt) { 228 mask &= ~(1<<rix); 229 goto nextrate; 230 } 231 232 /* rarely sample bit-rates that fail a lot */ 233 if (sn->stats[size_bin][rix].successive_failures > ssc->max_successive_failures && 234 ticks - sn->stats[size_bin][rix].last_tx < ssc->stale_failure_timeout) { 235 mask &= ~(1<<rix); 236 goto nextrate; 237 } 238 239 /* don't sample more than 2 rates higher for rates > 11M */ 240 if (DOT11RATE(rix) > 2*11 && rix > current_rix + 2) { 241 mask &= ~(1<<rix); 242 goto nextrate; 243 } 244 245 sn->last_sample_rix[size_bin] = rix; 246 return rix; 247 } 248 return current_rix; 249 #undef DOT11RATE 250 #undef MCS 251 } 252 253 static int 254 ath_rate_get_static_rix(struct ath_softc *sc, const struct ieee80211_node *ni) 255 { 256 #define RATE(_ix) (ni->ni_rates.rs_rates[(_ix)] & IEEE80211_RATE_VAL) 257 #define DOT11RATE(_ix) (rt->info[(_ix)].dot11Rate & IEEE80211_RATE_VAL) 258 #define MCS(_ix) (ni->ni_htrates.rs_rates[_ix] | IEEE80211_RATE_MCS) 259 const struct ieee80211_txparam *tp = ni->ni_txparms; 260 int srate; 261 262 /* Check MCS rates */ 263 for (srate = ni->ni_htrates.rs_nrates - 1; srate >= 0; srate--) { 264 if (MCS(srate) == tp->ucastrate) 265 return sc->sc_rixmap[tp->ucastrate]; 266 } 267 268 /* Check legacy rates */ 269 for (srate = ni->ni_rates.rs_nrates - 1; srate >= 0; srate--) { 270 if (RATE(srate) == tp->ucastrate) 271 return sc->sc_rixmap[tp->ucastrate]; 272 } 273 return -1; 274 #undef RATE 275 #undef DOT11RATE 276 #undef MCS 277 } 278 279 static void 280 ath_rate_update_static_rix(struct ath_softc *sc, struct ieee80211_node *ni) 281 { 282 struct ath_node *an = ATH_NODE(ni); 283 const struct ieee80211_txparam *tp = ni->ni_txparms; 284 struct sample_node *sn = ATH_NODE_SAMPLE(an); 285 286 if (tp != NULL && tp->ucastrate != IEEE80211_FIXED_RATE_NONE) { 287 /* 288 * A fixed rate is to be used; ucastrate is the IEEE code 289 * for this rate (sans basic bit). Check this against the 290 * negotiated rate set for the node. Note the fixed rate 291 * may not be available for various reasons so we only 292 * setup the static rate index if the lookup is successful. 293 */ 294 sn->static_rix = ath_rate_get_static_rix(sc, ni); 295 } else { 296 sn->static_rix = -1; 297 } 298 } 299 300 301 302 void 303 ath_rate_findrate(struct ath_softc *sc, struct ath_node *an, 304 int shortPreamble, size_t frameLen, 305 u_int8_t *rix0, int *try0, u_int8_t *txrate) 306 { 307 #define DOT11RATE(ix) (rt->info[ix].dot11Rate & IEEE80211_RATE_VAL) 308 #define MCS(ix) (rt->info[ix].dot11Rate | IEEE80211_RATE_MCS) 309 #define RATE(ix) (DOT11RATE(ix) / 2) 310 struct sample_node *sn = ATH_NODE_SAMPLE(an); 311 struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc); 312 struct ifnet *ifp = sc->sc_ifp; 313 struct ieee80211com *ic = ifp->if_l2com; 314 const HAL_RATE_TABLE *rt = sc->sc_currates; 315 const int size_bin = size_to_bin(frameLen); 316 int rix, mrr, best_rix, change_rates; 317 unsigned average_tx_time; 318 319 ath_rate_update_static_rix(sc, &an->an_node); 320 321 if (sn->static_rix != -1) { 322 rix = sn->static_rix; 323 *try0 = ATH_TXMAXTRY; 324 goto done; 325 } 326 327 /* XXX TODO: this doesn't know about 11gn vs 11g protection; teach it */ 328 mrr = sc->sc_mrretry && !(ic->ic_flags & IEEE80211_F_USEPROT); 329 330 best_rix = pick_best_rate(sn, rt, size_bin, !mrr); 331 if (best_rix >= 0) { 332 average_tx_time = sn->stats[size_bin][best_rix].average_tx_time; 333 } else { 334 average_tx_time = 0; 335 } 336 /* 337 * Limit the time measuring the performance of other tx 338 * rates to sample_rate% of the total transmission time. 339 */ 340 if (sn->sample_tt[size_bin] < average_tx_time * (sn->packets_since_sample[size_bin]*ssc->sample_rate/100)) { 341 rix = pick_sample_rate(ssc, sn, rt, size_bin); 342 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL, 343 &an->an_node, "size %u sample rate %d current rate %d", 344 bin_to_size(size_bin), RATE(rix), 345 RATE(sn->current_rix[size_bin])); 346 if (rix != sn->current_rix[size_bin]) { 347 sn->current_sample_rix[size_bin] = rix; 348 } else { 349 sn->current_sample_rix[size_bin] = -1; 350 } 351 sn->packets_since_sample[size_bin] = 0; 352 } else { 353 change_rates = 0; 354 if (!sn->packets_sent[size_bin] || best_rix == -1) { 355 /* no packet has been sent successfully yet */ 356 for (rix = rt->rateCount-1; rix > 0; rix--) { 357 if ((sn->ratemask & (1<<rix)) == 0) 358 continue; 359 /* 360 * Pick the highest rate <= 36 Mbps 361 * that hasn't failed. 362 */ 363 if (DOT11RATE(rix) <= 72 && 364 sn->stats[size_bin][rix].successive_failures == 0) { 365 break; 366 } 367 } 368 change_rates = 1; 369 best_rix = rix; 370 } else if (sn->packets_sent[size_bin] < 20) { 371 /* let the bit-rate switch quickly during the first few packets */ 372 change_rates = 1; 373 } else if (ticks - ssc->min_switch > sn->ticks_since_switch[size_bin]) { 374 /* min_switch seconds have gone by */ 375 change_rates = 1; 376 } else if (2*average_tx_time < sn->stats[size_bin][sn->current_rix[size_bin]].average_tx_time) { 377 /* the current bit-rate is twice as slow as the best one */ 378 change_rates = 1; 379 } 380 381 sn->packets_since_sample[size_bin]++; 382 383 if (change_rates) { 384 if (best_rix != sn->current_rix[size_bin]) { 385 IEEE80211_NOTE(an->an_node.ni_vap, 386 IEEE80211_MSG_RATECTL, 387 &an->an_node, 388 "%s: size %d switch rate %d (%d/%d) -> %d (%d/%d) after %d packets mrr %d", 389 __func__, 390 bin_to_size(size_bin), 391 RATE(sn->current_rix[size_bin]), 392 sn->stats[size_bin][sn->current_rix[size_bin]].average_tx_time, 393 sn->stats[size_bin][sn->current_rix[size_bin]].perfect_tx_time, 394 RATE(best_rix), 395 sn->stats[size_bin][best_rix].average_tx_time, 396 sn->stats[size_bin][best_rix].perfect_tx_time, 397 sn->packets_since_switch[size_bin], 398 mrr); 399 } 400 sn->packets_since_switch[size_bin] = 0; 401 sn->current_rix[size_bin] = best_rix; 402 sn->ticks_since_switch[size_bin] = ticks; 403 /* 404 * Set the visible txrate for this node. 405 */ 406 an->an_node.ni_txrate = (rt->info[best_rix].phy == IEEE80211_T_HT) ? MCS(best_rix) : DOT11RATE(best_rix); 407 } 408 rix = sn->current_rix[size_bin]; 409 sn->packets_since_switch[size_bin]++; 410 } 411 *try0 = mrr ? sn->sched[rix].t0 : ATH_TXMAXTRY; 412 done: 413 KASSERT(rix >= 0 && rix < rt->rateCount, ("rix is %d", rix)); 414 415 *rix0 = rix; 416 *txrate = rt->info[rix].rateCode 417 | (shortPreamble ? rt->info[rix].shortPreamble : 0); 418 sn->packets_sent[size_bin]++; 419 #undef DOT11RATE 420 #undef MCS 421 #undef RATE 422 } 423 424 /* 425 * Get the TX rates. Don't fiddle with short preamble flags for them; 426 * the caller can do that. 427 */ 428 void 429 ath_rate_getxtxrates(struct ath_softc *sc, struct ath_node *an, 430 uint8_t rix0, uint8_t *rix, uint8_t *try) 431 { 432 struct sample_node *sn = ATH_NODE_SAMPLE(an); 433 const struct txschedule *sched = &sn->sched[rix0]; 434 435 KASSERT(rix0 == sched->r0, ("rix0 (%x) != sched->r0 (%x)!\n", rix0, sched->r0)); 436 437 /* rix[0] = sched->r0; */ 438 rix[1] = sched->r1; 439 rix[2] = sched->r2; 440 rix[3] = sched->r3; 441 442 try[0] = sched->t0; 443 try[1] = sched->t1; 444 try[2] = sched->t2; 445 try[3] = sched->t3; 446 } 447 448 void 449 ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an, 450 struct ath_desc *ds, int shortPreamble, u_int8_t rix) 451 { 452 struct sample_node *sn = ATH_NODE_SAMPLE(an); 453 const struct txschedule *sched = &sn->sched[rix]; 454 const HAL_RATE_TABLE *rt = sc->sc_currates; 455 uint8_t rix1, s1code, rix2, s2code, rix3, s3code; 456 457 /* XXX precalculate short preamble tables */ 458 rix1 = sched->r1; 459 s1code = rt->info[rix1].rateCode 460 | (shortPreamble ? rt->info[rix1].shortPreamble : 0); 461 rix2 = sched->r2; 462 s2code = rt->info[rix2].rateCode 463 | (shortPreamble ? rt->info[rix2].shortPreamble : 0); 464 rix3 = sched->r3; 465 s3code = rt->info[rix3].rateCode 466 | (shortPreamble ? rt->info[rix3].shortPreamble : 0); 467 ath_hal_setupxtxdesc(sc->sc_ah, ds, 468 s1code, sched->t1, /* series 1 */ 469 s2code, sched->t2, /* series 2 */ 470 s3code, sched->t3); /* series 3 */ 471 } 472 473 static void 474 update_stats(struct ath_softc *sc, struct ath_node *an, 475 int frame_size, 476 int rix0, int tries0, 477 int rix1, int tries1, 478 int rix2, int tries2, 479 int rix3, int tries3, 480 int short_tries, int tries, int status) 481 { 482 struct sample_node *sn = ATH_NODE_SAMPLE(an); 483 struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc); 484 const int size_bin = size_to_bin(frame_size); 485 const int size = bin_to_size(size_bin); 486 int tt, tries_so_far; 487 int is_ht40 = (an->an_node.ni_chw == 40); 488 489 if (!IS_RATE_DEFINED(sn, rix0)) 490 return; 491 tt = calc_usecs_unicast_packet(sc, size, rix0, short_tries, 492 MIN(tries0, tries) - 1, is_ht40); 493 tries_so_far = tries0; 494 495 if (tries1 && tries_so_far < tries) { 496 if (!IS_RATE_DEFINED(sn, rix1)) 497 return; 498 tt += calc_usecs_unicast_packet(sc, size, rix1, short_tries, 499 MIN(tries1 + tries_so_far, tries) - tries_so_far - 1, is_ht40); 500 tries_so_far += tries1; 501 } 502 503 if (tries2 && tries_so_far < tries) { 504 if (!IS_RATE_DEFINED(sn, rix2)) 505 return; 506 tt += calc_usecs_unicast_packet(sc, size, rix2, short_tries, 507 MIN(tries2 + tries_so_far, tries) - tries_so_far - 1, is_ht40); 508 tries_so_far += tries2; 509 } 510 511 if (tries3 && tries_so_far < tries) { 512 if (!IS_RATE_DEFINED(sn, rix3)) 513 return; 514 tt += calc_usecs_unicast_packet(sc, size, rix3, short_tries, 515 MIN(tries3 + tries_so_far, tries) - tries_so_far - 1, is_ht40); 516 } 517 518 if (sn->stats[size_bin][rix0].total_packets < ssc->smoothing_minpackets) { 519 /* just average the first few packets */ 520 int avg_tx = sn->stats[size_bin][rix0].average_tx_time; 521 int packets = sn->stats[size_bin][rix0].total_packets; 522 sn->stats[size_bin][rix0].average_tx_time = (tt+(avg_tx*packets))/(packets+1); 523 } else { 524 /* use a ewma */ 525 sn->stats[size_bin][rix0].average_tx_time = 526 ((sn->stats[size_bin][rix0].average_tx_time * ssc->smoothing_rate) + 527 (tt * (100 - ssc->smoothing_rate))) / 100; 528 } 529 530 if (status != 0) { 531 int y; 532 sn->stats[size_bin][rix0].successive_failures++; 533 for (y = size_bin+1; y < NUM_PACKET_SIZE_BINS; y++) { 534 /* 535 * Also say larger packets failed since we 536 * assume if a small packet fails at a 537 * bit-rate then a larger one will also. 538 */ 539 sn->stats[y][rix0].successive_failures++; 540 sn->stats[y][rix0].last_tx = ticks; 541 sn->stats[y][rix0].tries += tries; 542 sn->stats[y][rix0].total_packets++; 543 } 544 } else { 545 sn->stats[size_bin][rix0].packets_acked++; 546 sn->stats[size_bin][rix0].successive_failures = 0; 547 } 548 sn->stats[size_bin][rix0].tries += tries; 549 sn->stats[size_bin][rix0].last_tx = ticks; 550 sn->stats[size_bin][rix0].total_packets++; 551 552 if (rix0 == sn->current_sample_rix[size_bin]) { 553 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL, 554 &an->an_node, 555 "%s: size %d %s sample rate %d tries (%d/%d) tt %d avg_tt (%d/%d)", 556 __func__, 557 size, 558 status ? "FAIL" : "OK", 559 rix0, short_tries, tries, tt, 560 sn->stats[size_bin][rix0].average_tx_time, 561 sn->stats[size_bin][rix0].perfect_tx_time); 562 sn->sample_tt[size_bin] = tt; 563 sn->current_sample_rix[size_bin] = -1; 564 } 565 } 566 567 static void 568 badrate(struct ifnet *ifp, int series, int hwrate, int tries, int status) 569 { 570 if_printf(ifp, "bad series%d hwrate 0x%x, tries %u ts_status 0x%x\n", 571 series, hwrate, tries, status); 572 } 573 574 void 575 ath_rate_tx_complete(struct ath_softc *sc, struct ath_node *an, 576 const struct ath_buf *bf) 577 { 578 struct ifnet *ifp = sc->sc_ifp; 579 struct ieee80211com *ic = ifp->if_l2com; 580 struct sample_node *sn = ATH_NODE_SAMPLE(an); 581 const struct ath_tx_status *ts = &bf->bf_status.ds_txstat; 582 const struct ath_desc *ds0 = &bf->bf_desc[0]; 583 int final_rix, short_tries, long_tries, frame_size; 584 const HAL_RATE_TABLE *rt = sc->sc_currates; 585 int mrr; 586 587 final_rix = rt->rateCodeToIndex[ts->ts_rate]; 588 short_tries = ts->ts_shortretry; 589 long_tries = ts->ts_longretry + 1; 590 frame_size = ds0->ds_ctl0 & 0x0fff; /* low-order 12 bits of ds_ctl0 */ 591 if (frame_size == 0) /* NB: should not happen */ 592 frame_size = 1500; 593 594 if (sn->ratemask == 0) { 595 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL, 596 &an->an_node, 597 "%s: size %d %s rate/try %d/%d no rates yet", 598 __func__, 599 bin_to_size(size_to_bin(frame_size)), 600 ts->ts_status ? "FAIL" : "OK", 601 short_tries, long_tries); 602 return; 603 } 604 mrr = sc->sc_mrretry && !(ic->ic_flags & IEEE80211_F_USEPROT); 605 if (!mrr || ts->ts_finaltsi == 0) { 606 if (!IS_RATE_DEFINED(sn, final_rix)) { 607 badrate(ifp, 0, ts->ts_rate, long_tries, ts->ts_status); 608 return; 609 } 610 /* 611 * Only one rate was used; optimize work. 612 */ 613 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL, 614 &an->an_node, "%s: size %d (%d bytes) %s rate/try %d %s/%d/%d", 615 __func__, 616 bin_to_size(size_to_bin(frame_size)), 617 frame_size, 618 ts->ts_status ? "FAIL" : "OK", 619 dot11rate(rt, final_rix), dot11rate_label(rt, final_rix), short_tries, long_tries); 620 update_stats(sc, an, frame_size, 621 final_rix, long_tries, 622 0, 0, 623 0, 0, 624 0, 0, 625 short_tries, long_tries, ts->ts_status); 626 } else { 627 int hwrates[4], tries[4], rix[4]; 628 int finalTSIdx = ts->ts_finaltsi; 629 int i; 630 631 /* 632 * Process intermediate rates that failed. 633 */ 634 ath_hal_gettxcompletionrates(sc->sc_ah, ds0, hwrates, tries); 635 636 for (i = 0; i < 4; i++) { 637 rix[i] = rt->rateCodeToIndex[hwrates[i]]; 638 } 639 640 IEEE80211_NOTE(an->an_node.ni_vap, IEEE80211_MSG_RATECTL, 641 &an->an_node, 642 "%s: size %d (%d bytes) finaltsidx %d tries %d %s rate/try [%d %s/%d %d %s/%d %d %s/%d %d %s/%d]", 643 __func__, 644 bin_to_size(size_to_bin(frame_size)), 645 frame_size, 646 finalTSIdx, 647 long_tries, 648 ts->ts_status ? "FAIL" : "OK", 649 dot11rate(rt, rix[0]), dot11rate_label(rt, rix[0]), tries[0], 650 dot11rate(rt, rix[1]), dot11rate_label(rt, rix[1]), tries[1], 651 dot11rate(rt, rix[2]), dot11rate_label(rt, rix[2]), tries[2], 652 dot11rate(rt, rix[3]), dot11rate_label(rt, rix[3]), tries[3]); 653 654 for (i = 0; i < 4; i++) { 655 if (tries[i] && !IS_RATE_DEFINED(sn, rix[i])) 656 badrate(ifp, 0, hwrates[i], tries[i], ts->ts_status); 657 } 658 659 /* 660 * NB: series > 0 are not penalized for failure 661 * based on the try counts under the assumption 662 * that losses are often bursty and since we 663 * sample higher rates 1 try at a time doing so 664 * may unfairly penalize them. 665 */ 666 if (tries[0]) { 667 update_stats(sc, an, frame_size, 668 rix[0], tries[0], 669 rix[1], tries[1], 670 rix[2], tries[2], 671 rix[3], tries[3], 672 short_tries, long_tries, 673 long_tries > tries[0]); 674 long_tries -= tries[0]; 675 } 676 677 if (tries[1] && finalTSIdx > 0) { 678 update_stats(sc, an, frame_size, 679 rix[1], tries[1], 680 rix[2], tries[2], 681 rix[3], tries[3], 682 0, 0, 683 short_tries, long_tries, 684 ts->ts_status); 685 long_tries -= tries[1]; 686 } 687 688 if (tries[2] && finalTSIdx > 1) { 689 update_stats(sc, an, frame_size, 690 rix[2], tries[2], 691 rix[3], tries[3], 692 0, 0, 693 0, 0, 694 short_tries, long_tries, 695 ts->ts_status); 696 long_tries -= tries[2]; 697 } 698 699 if (tries[3] && finalTSIdx > 2) { 700 update_stats(sc, an, frame_size, 701 rix[3], tries[3], 702 0, 0, 703 0, 0, 704 0, 0, 705 short_tries, long_tries, 706 ts->ts_status); 707 } 708 } 709 } 710 711 void 712 ath_rate_newassoc(struct ath_softc *sc, struct ath_node *an, int isnew) 713 { 714 if (isnew) 715 ath_rate_ctl_reset(sc, &an->an_node); 716 } 717 718 static const struct txschedule *mrr_schedules[IEEE80211_MODE_MAX+2] = { 719 NULL, /* IEEE80211_MODE_AUTO */ 720 series_11a, /* IEEE80211_MODE_11A */ 721 series_11g, /* IEEE80211_MODE_11B */ 722 series_11g, /* IEEE80211_MODE_11G */ 723 NULL, /* IEEE80211_MODE_FH */ 724 series_11a, /* IEEE80211_MODE_TURBO_A */ 725 series_11g, /* IEEE80211_MODE_TURBO_G */ 726 series_11a, /* IEEE80211_MODE_STURBO_A */ 727 series_11na, /* IEEE80211_MODE_11NA */ 728 series_11ng, /* IEEE80211_MODE_11NG */ 729 series_half, /* IEEE80211_MODE_HALF */ 730 series_quarter, /* IEEE80211_MODE_QUARTER */ 731 }; 732 733 /* 734 * Initialize the tables for a node. 735 */ 736 static void 737 ath_rate_ctl_reset(struct ath_softc *sc, struct ieee80211_node *ni) 738 { 739 #define RATE(_ix) (ni->ni_rates.rs_rates[(_ix)] & IEEE80211_RATE_VAL) 740 #define DOT11RATE(_ix) (rt->info[(_ix)].dot11Rate & IEEE80211_RATE_VAL) 741 #define MCS(_ix) (ni->ni_htrates.rs_rates[_ix] | IEEE80211_RATE_MCS) 742 struct ath_node *an = ATH_NODE(ni); 743 struct sample_node *sn = ATH_NODE_SAMPLE(an); 744 const HAL_RATE_TABLE *rt = sc->sc_currates; 745 int x, y, rix; 746 747 KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode)); 748 749 KASSERT(sc->sc_curmode < IEEE80211_MODE_MAX+2, 750 ("curmode %u", sc->sc_curmode)); 751 sn->sched = mrr_schedules[sc->sc_curmode]; 752 KASSERT(sn->sched != NULL, 753 ("no mrr schedule for mode %u", sc->sc_curmode)); 754 755 sn->static_rix = -1; 756 ath_rate_update_static_rix(sc, ni); 757 758 /* 759 * Construct a bitmask of usable rates. This has all 760 * negotiated rates minus those marked by the hal as 761 * to be ignored for doing rate control. 762 */ 763 sn->ratemask = 0; 764 /* MCS rates */ 765 if (ni->ni_flags & IEEE80211_NODE_HT) { 766 for (x = 0; x < ni->ni_htrates.rs_nrates; x++) { 767 rix = sc->sc_rixmap[MCS(x)]; 768 if (rix == 0xff) 769 continue; 770 /* skip rates marked broken by hal */ 771 if (!rt->info[rix].valid) 772 continue; 773 KASSERT(rix < SAMPLE_MAXRATES, 774 ("mcs %u has rix %d", MCS(x), rix)); 775 sn->ratemask |= 1<<rix; 776 } 777 } 778 779 /* Legacy rates */ 780 for (x = 0; x < ni->ni_rates.rs_nrates; x++) { 781 rix = sc->sc_rixmap[RATE(x)]; 782 if (rix == 0xff) 783 continue; 784 /* skip rates marked broken by hal */ 785 if (!rt->info[rix].valid) 786 continue; 787 KASSERT(rix < SAMPLE_MAXRATES, 788 ("rate %u has rix %d", RATE(x), rix)); 789 sn->ratemask |= 1<<rix; 790 } 791 #ifdef IEEE80211_DEBUG 792 if (ieee80211_msg(ni->ni_vap, IEEE80211_MSG_RATECTL)) { 793 uint32_t mask; 794 795 ieee80211_note(ni->ni_vap, "[%6D] %s: size 1600 rate/tt", 796 ni->ni_macaddr, ":", __func__); 797 for (mask = sn->ratemask, rix = 0; mask != 0; mask >>= 1, rix++) { 798 if ((mask & 1) == 0) 799 continue; 800 printf(" %d %s/%d", dot11rate(rt, rix), dot11rate_label(rt, rix), 801 calc_usecs_unicast_packet(sc, 1600, rix, 0,0, 802 (ni->ni_chw == 40))); 803 } 804 printf("\n"); 805 } 806 #endif 807 for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) { 808 int size = bin_to_size(y); 809 uint32_t mask; 810 811 sn->packets_sent[y] = 0; 812 sn->current_sample_rix[y] = -1; 813 sn->last_sample_rix[y] = 0; 814 /* XXX start with first valid rate */ 815 sn->current_rix[y] = ffs(sn->ratemask)-1; 816 817 /* 818 * Initialize the statistics buckets; these are 819 * indexed by the rate code index. 820 */ 821 for (rix = 0, mask = sn->ratemask; mask != 0; rix++, mask >>= 1) { 822 if ((mask & 1) == 0) /* not a valid rate */ 823 continue; 824 sn->stats[y][rix].successive_failures = 0; 825 sn->stats[y][rix].tries = 0; 826 sn->stats[y][rix].total_packets = 0; 827 sn->stats[y][rix].packets_acked = 0; 828 sn->stats[y][rix].last_tx = 0; 829 830 sn->stats[y][rix].perfect_tx_time = 831 calc_usecs_unicast_packet(sc, size, rix, 0, 0, 832 (ni->ni_chw == 40)); 833 sn->stats[y][rix].average_tx_time = 834 sn->stats[y][rix].perfect_tx_time; 835 } 836 } 837 #if 0 838 /* XXX 0, num_rates-1 are wrong */ 839 IEEE80211_NOTE(ni->ni_vap, IEEE80211_MSG_RATECTL, ni, 840 "%s: %d rates %d%sMbps (%dus)- %d%sMbps (%dus)", __func__, 841 sn->num_rates, 842 DOT11RATE(0)/2, DOT11RATE(0) % 1 ? ".5" : "", 843 sn->stats[1][0].perfect_tx_time, 844 DOT11RATE(sn->num_rates-1)/2, DOT11RATE(sn->num_rates-1) % 1 ? ".5" : "", 845 sn->stats[1][sn->num_rates-1].perfect_tx_time 846 ); 847 #endif 848 /* set the visible bit-rate */ 849 if (sn->static_rix != -1) 850 ni->ni_txrate = DOT11RATE(sn->static_rix); 851 else 852 ni->ni_txrate = RATE(0); 853 #undef RATE 854 #undef DOT11RATE 855 } 856 857 static void 858 sample_stats(void *arg, struct ieee80211_node *ni) 859 { 860 struct ath_softc *sc = arg; 861 const HAL_RATE_TABLE *rt = sc->sc_currates; 862 struct sample_node *sn = ATH_NODE_SAMPLE(ATH_NODE(ni)); 863 uint32_t mask; 864 int rix, y; 865 866 printf("\n[%s] refcnt %d static_rix %d ratemask 0x%x\n", 867 ether_sprintf(ni->ni_macaddr), ieee80211_node_refcnt(ni), 868 sn->static_rix, sn->ratemask); 869 for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) { 870 printf("[%4u] cur rix %d (%d %s) since switch: packets %d ticks %u\n", 871 bin_to_size(y), sn->current_rix[y], 872 dot11rate(rt, sn->current_rix[y]), 873 dot11rate_label(rt, sn->current_rix[y]), 874 sn->packets_since_switch[y], sn->ticks_since_switch[y]); 875 printf("[%4u] last sample %d cur sample %d packets sent %d\n", 876 bin_to_size(y), sn->last_sample_rix[y], 877 sn->current_sample_rix[y], sn->packets_sent[y]); 878 printf("[%4u] packets since sample %d sample tt %u\n", 879 bin_to_size(y), sn->packets_since_sample[y], 880 sn->sample_tt[y]); 881 } 882 for (mask = sn->ratemask, rix = 0; mask != 0; mask >>= 1, rix++) { 883 if ((mask & 1) == 0) 884 continue; 885 for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) { 886 if (sn->stats[y][rix].total_packets == 0) 887 continue; 888 printf("[%2u %s:%4u] %8d:%-8d (%3d%%) T %8d F %4d avg %5u last %u\n", 889 dot11rate(rt, rix), dot11rate_label(rt, rix), 890 bin_to_size(y), 891 sn->stats[y][rix].total_packets, 892 sn->stats[y][rix].packets_acked, 893 (100*sn->stats[y][rix].packets_acked)/sn->stats[y][rix].total_packets, 894 sn->stats[y][rix].tries, 895 sn->stats[y][rix].successive_failures, 896 sn->stats[y][rix].average_tx_time, 897 ticks - sn->stats[y][rix].last_tx); 898 } 899 } 900 } 901 902 static int 903 ath_rate_sysctl_stats(SYSCTL_HANDLER_ARGS) 904 { 905 struct ath_softc *sc = arg1; 906 struct ifnet *ifp = sc->sc_ifp; 907 struct ieee80211com *ic = ifp->if_l2com; 908 int error, v; 909 910 v = 0; 911 error = sysctl_handle_int(oidp, &v, 0, req); 912 if (error || !req->newptr) 913 return error; 914 ieee80211_iterate_nodes(&ic->ic_sta, sample_stats, sc); 915 return 0; 916 } 917 918 static int 919 ath_rate_sysctl_smoothing_rate(SYSCTL_HANDLER_ARGS) 920 { 921 struct sample_softc *ssc = arg1; 922 int rate, error; 923 924 rate = ssc->smoothing_rate; 925 error = sysctl_handle_int(oidp, &rate, 0, req); 926 if (error || !req->newptr) 927 return error; 928 if (!(0 <= rate && rate < 100)) 929 return EINVAL; 930 ssc->smoothing_rate = rate; 931 ssc->smoothing_minpackets = 100 / (100 - rate); 932 return 0; 933 } 934 935 static int 936 ath_rate_sysctl_sample_rate(SYSCTL_HANDLER_ARGS) 937 { 938 struct sample_softc *ssc = arg1; 939 int rate, error; 940 941 rate = ssc->sample_rate; 942 error = sysctl_handle_int(oidp, &rate, 0, req); 943 if (error || !req->newptr) 944 return error; 945 if (!(2 <= rate && rate <= 100)) 946 return EINVAL; 947 ssc->sample_rate = rate; 948 return 0; 949 } 950 951 static void 952 ath_rate_sysctlattach(struct ath_softc *sc, struct sample_softc *ssc) 953 { 954 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev); 955 struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev); 956 957 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 958 "smoothing_rate", CTLTYPE_INT | CTLFLAG_RW, ssc, 0, 959 ath_rate_sysctl_smoothing_rate, "I", 960 "sample: smoothing rate for avg tx time (%%)"); 961 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 962 "sample_rate", CTLTYPE_INT | CTLFLAG_RW, ssc, 0, 963 ath_rate_sysctl_sample_rate, "I", 964 "sample: percent air time devoted to sampling new rates (%%)"); 965 /* XXX max_successive_failures, stale_failure_timeout, min_switch */ 966 SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO, 967 "sample_stats", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 968 ath_rate_sysctl_stats, "I", "sample: print statistics"); 969 } 970 971 struct ath_ratectrl * 972 ath_rate_attach(struct ath_softc *sc) 973 { 974 struct sample_softc *ssc; 975 976 ssc = malloc(sizeof(struct sample_softc), M_DEVBUF, M_NOWAIT|M_ZERO); 977 if (ssc == NULL) 978 return NULL; 979 ssc->arc.arc_space = sizeof(struct sample_node); 980 ssc->smoothing_rate = 95; /* ewma percentage ([0..99]) */ 981 ssc->smoothing_minpackets = 100 / (100 - ssc->smoothing_rate); 982 ssc->sample_rate = 10; /* %time to try diff tx rates */ 983 ssc->max_successive_failures = 3; /* threshold for rate sampling*/ 984 ssc->stale_failure_timeout = 10 * hz; /* 10 seconds */ 985 ssc->min_switch = hz; /* 1 second */ 986 ath_rate_sysctlattach(sc, ssc); 987 return &ssc->arc; 988 } 989 990 void 991 ath_rate_detach(struct ath_ratectrl *arc) 992 { 993 struct sample_softc *ssc = (struct sample_softc *) arc; 994 995 free(ssc, M_DEVBUF); 996 } 997