SampleRate rate control algorithm for the ath driver

Submitted by:	John Bicket

sys/conf/files

@@ -401,6 +401,7 @@ dev/ata/atapi-fd.c		optional atapifd
 dev/ata/atapi-tape.c		optional atapist
 dev/ath/ath_rate/amrr/amrr.c 	optional ath_rate_amrr
 dev/ath/ath_rate/onoe/onoe.c 	optional ath_rate_onoe
+dev/ath/ath_rate/sample/sample.c 	optional ath_rate_sample
 dev/ath/if_ath.c		optional ath
 dev/ath/if_ath_pci.c		optional ath pci
 dev/awi/am79c930.c		optional awi

sys/dev/ath/ath_rate/sample/sample.c

@@ -0,0 +1,608 @@
+/*-
+ * Copyright (c) 2005 John Bicket
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
+ *    redistribution must be conditioned upon including a substantially
+ *    similar Disclaimer requirement for further binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * John Bicket's SampleRate control algorithm.
+ */
+#include "opt_inet.h"
+
+#include <sys/param.h>
+#include <sys/systm.h> 
+#include <sys/sysctl.h>
+#include <sys/module.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/errno.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+#include <sys/bus.h>
+
+#include <sys/socket.h>
+ 
+#include <net/if.h>
+#include <net/if_media.h>
+#include <net/if_arp.h>
+#include <net/ethernet.h>		/* XXX for ether_sprintf */
+
+#include <net80211/ieee80211_var.h>
+
+#include <net/bpf.h>
+
+#ifdef INET
+#include <netinet/in.h> 
+#include <netinet/if_ether.h>
+#endif
+
+#include <dev/ath/if_athvar.h>
+#include <dev/ath/ath_rate/sample/sample.h>
+#include <contrib/dev/ath/ah_desc.h>
+
+#define	SAMPLE_DEBUG
+#ifdef SAMPLE_DEBUG
+enum {
+	ATH_DEBUG_RATE		= 0x00000010,	/* rate control */
+};
+#define	DPRINTF(sc, _fmt, ...) do {				\
+	if (sc->sc_debug & ATH_DEBUG_RATE)			\
+		printf(_fmt, __VA_ARGS__);			\
+} while (0)
+#else
+#define	DPRINTF(sc, _fmt, ...)
+#endif
+
+/*
+ * This file is an implementation of the SampleRate algorithm
+ * in "Bit-rate Selection in Wireless Networks"
+ * (http://www.pdos.lcs.mit.edu/papers/jbicket-ms.ps)
+ *
+ * SampleRate chooses the bit-rate it predicts will provide the most
+ * throughput based on estimates of the expected per-packet
+ * transmission time for each bit-rate.  SampleRate periodically sends
+ * packets at bit-rates other than the current one to estimate when
+ * another bit-rate will provide better performance. SampleRate
+ * switches to another bit-rate when its estimated per-packet
+ * transmission time becomes smaller than the current bit-rate's.
+ * SampleRate reduces the number of bit-rates it must sample by
+ * eliminating those that could not perform better than the one
+ * currently being used.  SampleRate also stops probing at a bit-rate
+ * if it experiences several successive losses.
+ *
+ * The difference between the algorithm in the thesis and the one in this
+ * file is that the one in this file uses a ewma instead of a window.
+ *
+ */
+
+static void	ath_rate_ctl_start(struct ath_softc *, struct ieee80211_node *);
+
+static __inline int size_to_bin(int size) 
+{
+	int x = 0;
+	for (x = 0; x < NUM_PACKET_SIZE_BINS; x++) {
+		if (size < packet_size_bins[x]) {
+			return x;
+		}
+	}
+	return NUM_PACKET_SIZE_BINS-1;
+}
+static __inline int bin_to_size(int index) {
+	return packet_size_bins[index];
+}
+
+/*
+ * Setup rate codes for management/control frames.  We force
+ * all such frames to the lowest rate.
+ */
+static void
+ath_rate_setmgtrates(struct ath_softc *sc, struct ath_node *an)
+{
+	const HAL_RATE_TABLE *rt = sc->sc_currates;
+
+	/* setup rates for management frames */
+	/* XXX management/control frames always go at lowest speed */
+	an->an_tx_mgtrate = rt->info[0].rateCode;
+	an->an_tx_mgtratesp = an->an_tx_mgtrate
+			    | rt->info[0].shortPreamble;
+}
+
+void
+ath_rate_node_init(struct ath_softc *sc, struct ath_node *an)
+{
+	DPRINTF(sc, "%s:\n", __func__);
+	/* NB: assumed to be zero'd by caller */
+	ath_rate_setmgtrates(sc, an);
+}
+
+void
+ath_rate_node_cleanup(struct ath_softc *sc, struct ath_node *an)
+{
+	DPRINTF(sc, "%s:\n", __func__);
+}
+
+
+/*
+ * returns the ndx with the lowest average_tx_time,
+ * or -1 if all the average_tx_times are 0.
+ */
+static __inline int best_rate_ndx(struct sample_node *sn, int size_bin)
+{
+	int x = 0;
+        int best_rate_ndx = 0;
+        int best_rate_tt = 0;
+        for (x = 0; x < sn->num_rates; x++) {
+		int tt = sn->stats[size_bin][x].average_tx_time;
+		if (tt > 0) {
+			if (!best_rate_tt || best_rate_tt > tt) {
+				best_rate_tt = tt;
+				best_rate_ndx = x;
+			}
+		}
+        }
+        return (best_rate_tt) ? best_rate_ndx : -1;
+}
+
+/*
+ * pick a ndx s.t. the perfect_tx_time
+ * is less than the best bit-rate's average_tx_time
+ * and the ndx has not had four successive failures.
+ */
+static __inline int pick_sample_ndx(struct sample_node *sn, int size_bin) 
+{
+	int x = 0;
+	int best_ndx = best_rate_ndx(sn, size_bin);
+	int best_tt = 0;
+	int num_eligible = 0;
+	
+	if (best_ndx < 0) {
+		/* no successes yet, send at the lowest bit-rate */
+		return 0;
+	}
+	
+	best_tt = sn->stats[size_bin][best_ndx].average_tx_time;
+	sn->sample_num[size_bin]++;
+	
+	/*
+	 * first, find the number of bit-rates we could potentially
+	 * sample. we assume this list doesn't change a lot, so
+	 * we will just cycle through them.
+	 */
+	for (x = 0; x < sn->num_rates; x++) {
+		if (x != best_ndx && 
+		    sn->stats[size_bin][x].perfect_tx_time < best_tt &&
+		    sn->stats[size_bin][x].successive_failures < 4) {
+			num_eligible++;
+		}
+	}
+	
+	if (num_eligible > 0) {
+		int pick = sn->sample_num[size_bin] % num_eligible;
+		for (x = 0; x < sn->num_rates; x++) {
+			if (x != best_ndx && 
+			    sn->stats[size_bin][x].perfect_tx_time < best_tt &&
+			    sn->stats[size_bin][x].successive_failures < 4) {
+				if (pick == 0) {
+					return x;
+				}
+				pick--;
+			}
+		}
+	}
+	return best_ndx;
+}
+
+void
+ath_rate_findrate(struct ath_softc *sc, struct ath_node *an,
+		  HAL_BOOL shortPreamble, size_t frameLen,
+		  u_int8_t *rix, int *try0, u_int8_t *txrate)
+{
+	struct sample_node *sn = ATH_NODE_SAMPLE(an);
+	struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
+	int x;
+	int ndx = 0;
+	int size_bin = size_to_bin(frameLen);
+	int best_ndx = best_rate_ndx(sn, size_bin);
+
+	if (sn->static_rate_ndx != -1) {
+		*try0 = 4;
+		*rix = sn->rates[sn->static_rate_ndx].rix;
+		*txrate = sn->rates[sn->static_rate_ndx].rateCode;
+		return;
+	}
+	
+	*try0 = 2;
+	
+	best_ndx = best_rate_ndx(sn, size_bin);
+	if (!sn->packets_sent[size_bin] || 
+	    sn->packets_sent[size_bin] % ssc->ath_sample_rate > 0) {
+		/*
+		 * for most packets, send the packet at the bit-rate with 
+		 * the lowest estimated transmission time.
+		 */
+		if (best_ndx != -1) {
+			ndx = best_ndx;
+		} else {
+			/* 
+			 * no packet has succeeded, try the highest bitrate
+			 * that hasn't failed.
+			 */  
+			for (ndx = sn->num_rates-1; ndx >= 0; ndx--) {
+				if (sn->stats[size_bin][ndx].successive_failures == 0) {
+					break;
+				}
+			}
+		}
+		if (size_bin == 0) {
+			/* update the visible txrate for this node */
+			an->an_node.ni_txrate = ndx;
+		}
+	} else {
+		/* 
+		 * before we pick a bit-rate to "sample", clear any
+		 * stale stuff out.
+		 */
+		for (x = 0; x < sn->num_rates; x++) {
+			if (ticks - sn->stats[size_bin][x].last_tx > ((hz * 10000)/1000)) {
+				sn->stats[size_bin][x].average_tx_time = sn->stats[size_bin][x].perfect_tx_time;
+				sn->stats[size_bin][x].successive_failures = 0;
+				sn->stats[size_bin][x].tries = 0;
+				sn->stats[size_bin][x].total_packets = 0;
+				sn->stats[size_bin][x].packets_acked = 0;
+			}
+		}
+
+		/* send the packet at a different bit-rate */
+		ndx = pick_sample_ndx(sn, size_bin);
+	}
+	
+	
+	*rix = sn->rates[ndx].rix;
+	if (shortPreamble) {
+		*txrate = sn->rates[ndx].shortPreambleRateCode;
+	} else {
+		
+		*txrate = sn->rates[ndx].rateCode;
+	}
+	
+	sn->packets_sent[size_bin]++;
+}
+
+void
+ath_rate_setupxtxdesc(struct ath_softc *sc, struct ath_node *an,
+		      struct ath_desc *ds, HAL_BOOL shortPreamble, u_int8_t rix)
+{
+	struct sample_node *sn = ATH_NODE_SAMPLE(an);
+	int rateCode = -1;
+	int frame_size;
+	int size_bin;
+	int best_ndx;
+
+	frame_size = ds->ds_ctl0 & 0x0fff; /* low-order 12 bits of ds_ctl0 */
+	if (frame_size == 0)
+		frame_size = 1500;
+	size_bin = size_to_bin(frame_size);
+	best_ndx = best_rate_ndx(sn, size_bin);
+
+	if (best_ndx == -1 || !sn->stats[size_bin][best_ndx].packets_acked) {
+		/* 
+		 * no packet has succeeded, so also try twice at the lowest bitate.
+		 */
+		if (shortPreamble) {
+			rateCode = sn->rates[0].shortPreambleRateCode;
+		} else {
+			rateCode = sn->rates[0].rateCode;
+		}
+	} else if (sn->rates[best_ndx].rix != rix) {
+		/*
+		 * we're trying a different bit-rate, and it could be lossy, 
+		 * so if it fails try at the best bit-rate.
+		 */
+		if (shortPreamble) {
+			rateCode = sn->rates[MAX(0,best_ndx-1)].shortPreambleRateCode;
+		} else {
+			rateCode = sn->rates[MAX(0,best_ndx-1)].rateCode;
+		}
+	}
+	if (rateCode != -1) {
+		ath_hal_setupxtxdesc(sc->sc_ah, ds
+				     , rateCode, 1	/* series 1 */
+				     , rateCode, 1	        /* series 2 */
+				     , rateCode, 1	        /* series 3 */
+				     );
+	}
+	
+}
+
+void
+ath_rate_tx_complete(struct ath_softc *sc,
+		     struct ath_node *an, const struct ath_desc *ds)
+{
+	struct sample_node *sn = ATH_NODE_SAMPLE(an);
+	struct sample_softc *ssc = ATH_SOFTC_SAMPLE(sc);
+	int rate = sc->sc_hwmap[ds->ds_txstat.ts_rate &~ HAL_TXSTAT_ALTRATE].ieeerate;
+	int retries = ds->ds_txstat.ts_longretry;
+	int initial_rate_failed = ((ds->ds_txstat.ts_rate & HAL_TXSTAT_ALTRATE)
+				   || ds->ds_txstat.ts_status != 0 ||
+				   retries > 3);
+	int tt = 0;
+	int rix = -1;
+	int x = 0;
+	int frame_size; /* low-order 12 bits of ds_ctl0 */
+	int size_bin;
+	int size;
+
+	if (!sn->num_rates) {
+		DPRINTF(sc, "%s: no rates yet\n", __func__);
+		return;
+	}
+	for (x = 0; x < sn->num_rates; x++) {
+		if (sn->rates[x].rate == rate) {
+			rix = x;
+			break;
+		}      
+	}
+	
+	if (rix < 0 || rix > sn->num_rates) {
+		/* maybe a management packet */
+		return;
+	}
+
+	frame_size = ds->ds_ctl0 & 0x0fff; /* low-order 12 bits of ds_ctl0 */
+	if (frame_size == 0)
+		frame_size = 1500;
+	size_bin = size_to_bin(frame_size);
+	size = bin_to_size(size_bin);
+	tt = calc_usecs_unicast_packet(sc, size, sn->rates[rix].rix, 
+				       retries);
+
+	DPRINTF(sc, "%s: rate %d rix %d frame_size %d (%d) retries %d status %d tt %d avg_tt %d perfect_tt %d ts-rate %d\n", 
+		__func__, rate, rix, frame_size, size, retries, initial_rate_failed, tt, 
+		sn->stats[size_bin][rix].average_tx_time,
+		sn->stats[size_bin][rix].perfect_tx_time,
+		ds->ds_txstat.ts_rate);
+	
+	if (sn->stats[size_bin][rix].total_packets < 7) {
+		/* just average the first few packets */
+		int avg_tx = sn->stats[size_bin][rix].average_tx_time;
+		int packets = sn->stats[size_bin][rix].total_packets;
+		sn->stats[size_bin][rix].average_tx_time = (tt+(avg_tx*packets))/(packets+1);
+	} else {
+		/* use a ewma */
+		sn->stats[size_bin][rix].average_tx_time = 
+			((sn->stats[size_bin][rix].average_tx_time * ssc->ath_smoothing_rate) + 
+			 (tt * (100 - ssc->ath_smoothing_rate))) / 100;
+	}
+	
+	if (initial_rate_failed) {
+		/* 
+		 * this packet failed - count this as a failure
+		 * for larger packets also, since we assume
+		 * if a small packet fails at a lower bit-rate 
+		 * then a larger one will also.
+		 */
+		int y;
+		for (y = size_bin; y < NUM_PACKET_SIZE_BINS; y++) {
+			sn->stats[y][rix].successive_failures++;
+			sn->stats[y][rix].last_tx = ticks;
+		}
+	} else {
+		sn->stats[size_bin][rix].packets_acked++;
+		sn->stats[size_bin][rix].successive_failures = 0;
+	}
+	sn->stats[size_bin][rix].tries += (1+retries);
+	sn->stats[size_bin][rix].last_tx = ticks;
+	sn->stats[size_bin][rix].total_packets++;
+}
+
+void
+ath_rate_newassoc(struct ath_softc *sc, struct ath_node *an, int isnew)
+{
+	DPRINTF(sc, "%s:\n", __func__);
+	if (isnew)
+		ath_rate_ctl_start(sc, &an->an_node);
+}
+
+static void
+ath_rate_ctl_reset(struct ath_softc *sc, struct ieee80211_node *ni)
+{
+	struct ath_node *an = ATH_NODE(ni);
+	struct sample_node *sn = ATH_NODE_SAMPLE(an);
+	int x = 0;
+	int y = 0;
+
+	for (y = 0; y < NUM_PACKET_SIZE_BINS; y++) {
+		int size = bin_to_size(y);
+		sn->packets_sent[y] = 0;
+		sn->sample_num[y] = 0;
+
+		for (x = 0; x < ni->ni_rates.rs_nrates; x++) {
+			sn->stats[y][x].successive_failures = 0;
+			sn->stats[y][x].tries = 0;
+			sn->stats[y][x].total_packets = 0;
+			sn->stats[y][x].packets_acked = 0;
+			sn->stats[y][x].last_tx = 0;
+			sn->stats[y][x].perfect_tx_time = calc_usecs_unicast_packet(sc, size, 
+									      sn->rates[x].rix,
+									      0);
+			sn->stats[y][x].average_tx_time = sn->stats[y][x].perfect_tx_time;
+
+			
+			DPRINTF(sc, "%s: %d rate %d rix %d rateCode %d perfect_tx_time %d \n", __func__, 
+				x, sn->rates[x].rate, 
+				sn->rates[x].rix, sn->rates[x].rateCode,
+				sn->stats[0][x].perfect_tx_time);
+		}
+
+	}
+	
+	/* set the visible bit-rate to the lowest one available */
+	ni->ni_txrate = 0;
+
+}
+
+/*
+ * Initialize the tables for a node.
+ */
+static void
+ath_rate_ctl_start(struct ath_softc *sc, struct ieee80211_node *ni)
+{
+#define	RATE(_ix)	(ni->ni_rates.rs_rates[(_ix)] & IEEE80211_RATE_VAL)
+	struct ieee80211com *ic = &sc->sc_ic;
+	struct ath_node *an = ATH_NODE(ni);
+	struct sample_node *sn = ATH_NODE_SAMPLE(an);
+	const HAL_RATE_TABLE *rt = sc->sc_currates;
+
+	int x;
+	int srate;
+
+        DPRINTF(sc, "%s:\n", __func__);
+	KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
+	KASSERT(ni->ni_rates.rs_nrates > 0, ("no rates"));
+        sn->static_rate_ndx = -1;
+	if (ic->ic_fixed_rate != -1) {
+		/*
+		 * A fixed rate is to be used; ic_fixed_rate is an
+		 * index into the supported rate set.  Convert this
+		 * to the index into the negotiated rate set for
+		 * the node.  We know the rate is there because the
+		 * rate set is checked when the station associates.
+		 */
+		const struct ieee80211_rateset *rs =
+			&ic->ic_sup_rates[ic->ic_curmode];
+		int r = rs->rs_rates[ic->ic_fixed_rate] & IEEE80211_RATE_VAL;
+		/* NB: the rate set is assumed sorted */
+		srate = ni->ni_rates.rs_nrates - 1;
+		for (; srate >= 0 && RATE(srate) != r; srate--)
+			;
+		KASSERT(srate >= 0,
+			("fixed rate %d not in rate set", ic->ic_fixed_rate));
+                sn->static_rate_ndx = srate;
+                        
+	}
+	sn->num_rates = ni->ni_rates.rs_nrates;
+        for (x = 0; x < ni->ni_rates.rs_nrates; x++) {
+          sn->rates[x].rate = ni->ni_rates.rs_rates[x] & IEEE80211_RATE_VAL;
+          sn->rates[x].rix = sc->sc_rixmap[sn->rates[x].rate];
+          sn->rates[x].rateCode = rt->info[sn->rates[x].rix].rateCode;
+          sn->rates[x].shortPreambleRateCode = 
+		  rt->info[sn->rates[x].rix].rateCode | 
+		  rt->info[sn->rates[x].rix].shortPreamble;
+	}
+	ath_rate_ctl_reset(sc, ni);
+
+#undef RATE
+}
+
+/*
+ * Reset the rate control state for each 802.11 state transition.
+ */
+void
+ath_rate_newstate(struct ath_softc *sc, enum ieee80211_state state)
+{
+	struct ieee80211com *ic = &sc->sc_ic;
+
+	if (state == IEEE80211_S_RUN)
+		ath_rate_newassoc(sc, ATH_NODE(ic->ic_bss), 1);
+}
+
+static void
+ath_rate_sysctlattach(struct ath_softc *sc, struct sample_softc *osc)
+{
+	struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(sc->sc_dev);
+	struct sysctl_oid *tree = device_get_sysctl_tree(sc->sc_dev);
+
+	/* XXX bounds check [0..100] */
+	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+		"smoothing_rate", CTLFLAG_RW, &osc->ath_smoothing_rate, 0,
+		"rate control: retry threshold to credit rate raise (%%)");
+	/* XXX bounds check [2..100] */
+	SYSCTL_ADD_INT(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+		"sample_rate", CTLFLAG_RW, &osc->ath_sample_rate,0,
+		"rate control: # good periods before raising rate");
+}
+
+struct ath_ratectrl *
+ath_rate_attach(struct ath_softc *sc)
+{
+	struct sample_softc *osc;
+	
+	DPRINTF(sc, "%s:\n", __func__);
+	osc = malloc(sizeof(struct sample_softc), M_DEVBUF, M_NOWAIT|M_ZERO);
+	if (osc == NULL)
+		return NULL;
+	osc->arc.arc_space = sizeof(struct sample_node);
+	osc->ath_smoothing_rate = 95;	/* ewma percentage (out of 100) */
+	osc->ath_sample_rate = 10;	/* send a different bit-rate 1/X packets */
+	ath_rate_sysctlattach(sc, osc);
+	return &osc->arc;
+}
+
+void
+ath_rate_detach(struct ath_ratectrl *arc)
+{
+	struct sample_softc *osc = (struct sample_softc *) arc;
+	
+	free(osc, M_DEVBUF);
+}
+
+/*
+ * Module glue.
+ */
+static int
+sample_modevent(module_t mod, int type, void *unused)
+{
+	switch (type) {
+	case MOD_LOAD:
+		if (bootverbose)
+			printf("ath_rate: <SampleRate bit-rate selection algorithm>\n");
+		return 0;
+	case MOD_UNLOAD:
+		return 0;
+	}
+	return EINVAL;
+}
+
+static moduledata_t sample_mod = {
+	"ath_rate",
+	sample_modevent,
+	0
+};
+DECLARE_MODULE(ath_rate, sample_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
+MODULE_VERSION(ath_rate, 1);
+MODULE_DEPEND(ath_rate, wlan, 1, 1, 1);

sys/dev/ath/ath_rate/sample/sample.h

@@ -0,0 +1,136 @@
+/*-
+ * Copyright (c) 2005 John Bicket
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer,
+ *    without modification.
+ * 2. Redistributions in binary form must reproduce at minimum a disclaimer
+ *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
+ *    redistribution must be conditioned upon including a substantially
+ *    similar Disclaimer requirement for further binary redistribution.
+ * 3. Neither the names of the above-listed copyright holders nor the names
+ *    of any contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
+ * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+ * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGES.
+ *
+ * $FreeBSD$
+ */
+
+/*
+ * Defintions for the Atheros Wireless LAN controller driver.
+ */
+#ifndef _DEV_ATH_RATE_SAMPLE_H
+#define _DEV_ATH_RATE_SAMPLE_H
+
+/* per-device state */
+struct sample_softc {
+	struct ath_ratectrl arc;	/* base state */
+	int	ath_smoothing_rate;	/* ewma percentage (out of 100) */
+	int	ath_sample_rate;	/* send a different bit-rate 1/X packets */
+};
+#define	ATH_SOFTC_SAMPLE(sc)	((struct sample_softc *)sc->sc_rc)
+
+struct rate_info {
+	int rate;
+	int rix;
+	int rateCode;
+	int shortPreambleRateCode;
+};
+
+
+struct rate_stats {	
+	int average_tx_time;
+	int successive_failures;
+	int tries;
+	int total_packets;
+	int packets_acked;
+	int perfect_tx_time; /* transmit time for 0 retries */
+	int last_tx;
+};
+
+/*
+ * for now, we track performance for three different packet
+ * size buckets
+ */
+#define NUM_PACKET_SIZE_BINS 3
+static int packet_size_bins[NUM_PACKET_SIZE_BINS] = {250, 1600, 3000};
+
+/* per-node state */
+struct sample_node {
+	int static_rate_ndx;
+	int num_rates;
+
+	struct rate_info rates[IEEE80211_RATE_MAXSIZE];
+	
+	struct rate_stats stats[NUM_PACKET_SIZE_BINS][IEEE80211_RATE_MAXSIZE];
+	int sample_num[NUM_PACKET_SIZE_BINS];       
+	int packets_sent[NUM_PACKET_SIZE_BINS];
+
+};
+#define	ATH_NODE_SAMPLE(an)	((struct sample_node *)&an[1])
+
+#ifndef MIN
+#define	MIN(a,b)	((a) < (b) ? (a) : (b))
+#endif
+#ifndef MAX
+#define	MAX(a,b)	((a) > (b) ? (a) : (b))
+#endif
+
+#define WIFI_CW_MIN 31
+#define WIFI_CW_MAX 1023
+
+/*
+ * Calculate the transmit duration of a frame.
+ */
+static unsigned calc_usecs_unicast_packet(struct ath_softc *sc,
+				int length, 
+				int rix, int retries) {
+	const HAL_RATE_TABLE *rt = sc->sc_currates;
+
+	
+	/* pg 205 ieee.802.11.pdf */
+	unsigned t_slot = 20;
+	unsigned t_difs = 50; 
+	unsigned t_sifs = 10; 
+	int tt = 0;
+	int x = 0;
+	int cw = WIFI_CW_MIN;
+	int cix = rt->info[rix].controlRate;
+	KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
+	
+	if (rt->info[rix].phy == IEEE80211_T_OFDM) {
+		t_slot = 9;
+		t_sifs = 9;
+		t_difs = 28;
+	}
+	tt += t_difs;
+	tt += (retries+1)*(t_sifs + rt->info[cix].spAckDuration);
+	tt += (retries+1)*ath_hal_computetxtime(sc->sc_ah, rt, length, 
+						rix, AH_TRUE);
+	for (x = 0; x <= retries; x++) {
+		cw = MIN(WIFI_CW_MAX, (cw + 1) * 2);
+		tt += (t_slot * cw/2);
+	}
+	return tt;
+}
+#endif /* _DEV_ATH_RATE_SAMPLE_H */

sys/i386/conf/NOTES

@@ -585,6 +585,7 @@ device		ath
 device		ath_hal		# Atheros HAL (includes binary component)
 device		ath_rate_onoe	# Onoe rate control for ath driver
 #device		ath_rate_amrr	# AMRR rate control for ath driver
+#device		ath_rate_sample	# SampleRate rate control for the ath driver
 #device		wlan		# 802.11 layer
 
 #

sys/modules/Makefile

@@ -27,6 +27,7 @@ SUBDIR=	${_3dfx} \
 	${_ath_hal} \
 	ath_rate_amrr \
 	ath_rate_onoe \
+	ath_rate_sample \
 	aue \
 	${_auxio} \
 	${_awi} \

sys/modules/ath_rate_sample/Makefile

@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2004 Sam Leffler, Errno Consulting
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer,
+#    without modification.
+# 2. Redistributions in binary form must reproduce at minimum a disclaimer
+#    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
+#    redistribution must be conditioned upon including a substantially
+#    similar Disclaimer requirement for further binary redistribution.
+# 3. Neither the names of the above-listed copyright holders nor the names
+#    of any contributors may be used to endorse or promote products derived
+#    from this software without specific prior written permission.
+#
+# Alternatively, this software may be distributed under the terms of the
+# GNU General Public License ("GPL") version 2 as published by the Free
+# Software Foundation.
+#
+# NO WARRANTY
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+# THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
+# OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
+# IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+# THE POSSIBILITY OF SUCH DAMAGES.
+#
+# $FreeBSD$
+#
+
+.PATH: ${.CURDIR}/../../dev/ath/ath_rate/sample
+
+KMOD=	ath_rate
+SRCS=	sample.c
+SRCS+=	opt_bdg.h device_if.h bus_if.h pci_if.h opt_inet.h
+
+HAL=	${.CURDIR}/../../contrib/dev/ath
+CFLAGS+=  -I. -I${HAL}/freebsd -I${HAL}
+
+.include <bsd.kmod.mk>