mirror of https://github.com/hak5/openwrt-owl.git
mac80211: merge upstream legacy minstrel improvements
Signed-off-by: Felix Fietkau <nbd@openwrt.org> SVN-Revision: 36334owl
Felix Fietkau
parent
604395650a
commit
fb79dbfb7b
|
|
@ -634,7 +634,16 @@
|
|||
rt2x00dev->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
|
||||
--- a/net/mac80211/rc80211_minstrel_ht.c
|
||||
+++ b/net/mac80211/rc80211_minstrel_ht.c
|
||||
@@ -26,11 +26,11 @@
|
||||
@@ -17,8 +17,6 @@
|
||||
#include "rc80211_minstrel_ht.h"
|
||||
|
||||
#define AVG_PKT_SIZE 1200
|
||||
-#define SAMPLE_COLUMNS 10
|
||||
-#define EWMA_LEVEL 75
|
||||
|
||||
/* Number of bits for an average sized packet */
|
||||
#define MCS_NBITS (AVG_PKT_SIZE << 3)
|
||||
@@ -26,11 +24,11 @@
|
||||
/* Number of symbols for a packet with (bps) bits per symbol */
|
||||
#define MCS_NSYMS(bps) ((MCS_NBITS + (bps) - 1) / (bps))
|
||||
|
||||
|
|
@ -649,7 +658,7 @@
|
|||
)
|
||||
|
||||
/* Transmit duration for the raw data part of an average sized packet */
|
||||
@@ -64,9 +64,9 @@
|
||||
@@ -64,9 +62,9 @@
|
||||
}
|
||||
|
||||
#define CCK_DURATION(_bitrate, _short, _len) \
|
||||
|
|
@ -661,7 +670,23 @@
|
|||
|
||||
#define CCK_ACK_DURATION(_bitrate, _short) \
|
||||
(CCK_DURATION((_bitrate > 10 ? 20 : 10), false, 60) + \
|
||||
@@ -211,20 +211,32 @@ static void
|
||||
@@ -129,15 +127,6 @@ const struct mcs_group minstrel_mcs_grou
|
||||
static u8 sample_table[SAMPLE_COLUMNS][MCS_GROUP_RATES];
|
||||
|
||||
/*
|
||||
- * Perform EWMA (Exponentially Weighted Moving Average) calculation
|
||||
- */
|
||||
-static int
|
||||
-minstrel_ewma(int old, int new, int weight)
|
||||
-{
|
||||
- return (new * (100 - weight) + old * weight) / 100;
|
||||
-}
|
||||
-
|
||||
-/*
|
||||
* Look up an MCS group index based on mac80211 rate information
|
||||
*/
|
||||
static int
|
||||
@@ -211,20 +200,32 @@ static void
|
||||
minstrel_ht_calc_tp(struct minstrel_ht_sta *mi, int group, int rate)
|
||||
{
|
||||
struct minstrel_rate_stats *mr;
|
||||
|
|
@ -689,17 +714,17 @@
|
|||
if (group != MINSTREL_CCK_GROUP)
|
||||
- usecs = mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
|
||||
+ nsecs = 1000 * mi->overhead / MINSTREL_TRUNC(mi->avg_ampdu_len);
|
||||
+
|
||||
+ nsecs += minstrel_mcs_groups[group].duration[rate];
|
||||
+ tp = 1000000 * ((mr->probability * 1000) / nsecs);
|
||||
|
||||
- usecs += minstrel_mcs_groups[group].duration[rate];
|
||||
- mr->cur_tp = MINSTREL_TRUNC((1000000 / usecs) * mr->probability);
|
||||
+ nsecs += minstrel_mcs_groups[group].duration[rate];
|
||||
+ tp = 1000000 * ((mr->probability * 1000) / nsecs);
|
||||
+
|
||||
+ mr->cur_tp = MINSTREL_TRUNC(tp);
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -308,8 +320,8 @@ minstrel_ht_update_stats(struct minstrel
|
||||
@@ -308,8 +309,8 @@ minstrel_ht_update_stats(struct minstrel
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -710,7 +735,7 @@
|
|||
|
||||
cur_prob = 0;
|
||||
cur_prob_tp = 0;
|
||||
@@ -320,20 +332,13 @@ minstrel_ht_update_stats(struct minstrel
|
||||
@@ -320,20 +321,13 @@ minstrel_ht_update_stats(struct minstrel
|
||||
if (!mg->supported)
|
||||
continue;
|
||||
|
||||
|
|
@ -732,7 +757,7 @@
|
|||
}
|
||||
|
||||
mr = minstrel_get_ratestats(mi, mg->max_tp_rate2);
|
||||
@@ -343,6 +348,23 @@ minstrel_ht_update_stats(struct minstrel
|
||||
@@ -343,6 +337,23 @@ minstrel_ht_update_stats(struct minstrel
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -756,7 +781,7 @@
|
|||
mi->stats_update = jiffies;
|
||||
}
|
||||
|
||||
@@ -467,7 +489,7 @@ minstrel_ht_tx_status(void *priv, struct
|
||||
@@ -467,7 +478,7 @@ minstrel_ht_tx_status(void *priv, struct
|
||||
|
||||
if (!mi->sample_wait && !mi->sample_tries && mi->sample_count > 0) {
|
||||
mi->sample_wait = 16 + 2 * MINSTREL_TRUNC(mi->avg_ampdu_len);
|
||||
|
|
@ -765,7 +790,7 @@
|
|||
mi->sample_count--;
|
||||
}
|
||||
|
||||
@@ -536,7 +558,7 @@ minstrel_calc_retransmit(struct minstrel
|
||||
@@ -536,7 +547,7 @@ minstrel_calc_retransmit(struct minstrel
|
||||
mr->retry_updated = true;
|
||||
|
||||
group = &minstrel_mcs_groups[index / MCS_GROUP_RATES];
|
||||
|
|
@ -774,7 +799,7 @@
|
|||
|
||||
/* Contention time for first 2 tries */
|
||||
ctime = (t_slot * cw) >> 1;
|
||||
@@ -616,6 +638,7 @@ minstrel_get_sample_rate(struct minstrel
|
||||
@@ -616,6 +627,7 @@ minstrel_get_sample_rate(struct minstrel
|
||||
{
|
||||
struct minstrel_rate_stats *mr;
|
||||
struct minstrel_mcs_group_data *mg;
|
||||
|
|
@ -782,7 +807,7 @@
|
|||
int sample_idx = 0;
|
||||
|
||||
if (mi->sample_wait > 0) {
|
||||
@@ -626,39 +649,46 @@ minstrel_get_sample_rate(struct minstrel
|
||||
@@ -626,39 +638,46 @@ minstrel_get_sample_rate(struct minstrel
|
||||
if (!mi->sample_tries)
|
||||
return -1;
|
||||
|
||||
|
|
@ -840,7 +865,19 @@
|
|||
}
|
||||
--- a/net/mac80211/rc80211_minstrel_ht.h
|
||||
+++ b/net/mac80211/rc80211_minstrel_ht.h
|
||||
@@ -85,6 +85,7 @@ struct minstrel_ht_sta {
|
||||
@@ -16,11 +16,6 @@
|
||||
#define MINSTREL_MAX_STREAMS 3
|
||||
#define MINSTREL_STREAM_GROUPS 4
|
||||
|
||||
-/* scaled fraction values */
|
||||
-#define MINSTREL_SCALE 16
|
||||
-#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
|
||||
-#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
|
||||
-
|
||||
#define MCS_GROUP_RATES 8
|
||||
|
||||
struct mcs_group {
|
||||
@@ -85,6 +80,7 @@ struct minstrel_ht_sta {
|
||||
|
||||
/* best probability rate */
|
||||
unsigned int max_prob_rate;
|
||||
|
|
@ -1161,3 +1198,434 @@
|
|||
|
||||
if (ifmgd->auth_data && !ifmgd->auth_data->done) {
|
||||
err = -EBUSY;
|
||||
--- a/net/mac80211/rc80211_minstrel.c
|
||||
+++ b/net/mac80211/rc80211_minstrel.c
|
||||
@@ -55,7 +55,6 @@
|
||||
#include "rate.h"
|
||||
#include "rc80211_minstrel.h"
|
||||
|
||||
-#define SAMPLE_COLUMNS 10
|
||||
#define SAMPLE_TBL(_mi, _idx, _col) \
|
||||
_mi->sample_table[(_idx * SAMPLE_COLUMNS) + _col]
|
||||
|
||||
@@ -70,16 +69,31 @@ rix_to_ndx(struct minstrel_sta_info *mi,
|
||||
return i;
|
||||
}
|
||||
|
||||
+/* find & sort topmost throughput rates */
|
||||
+static inline void
|
||||
+minstrel_sort_best_tp_rates(struct minstrel_sta_info *mi, int i, u8 *tp_list)
|
||||
+{
|
||||
+ int j = MAX_THR_RATES;
|
||||
+
|
||||
+ while (j > 0 && mi->r[i].cur_tp > mi->r[tp_list[j - 1]].cur_tp)
|
||||
+ j--;
|
||||
+ if (j < MAX_THR_RATES - 1)
|
||||
+ memmove(&tp_list[j + 1], &tp_list[j], MAX_THR_RATES - (j + 1));
|
||||
+ if (j < MAX_THR_RATES)
|
||||
+ tp_list[j] = i;
|
||||
+}
|
||||
+
|
||||
static void
|
||||
minstrel_update_stats(struct minstrel_priv *mp, struct minstrel_sta_info *mi)
|
||||
{
|
||||
- u32 max_tp = 0, index_max_tp = 0, index_max_tp2 = 0;
|
||||
- u32 max_prob = 0, index_max_prob = 0;
|
||||
+ u8 tmp_tp_rate[MAX_THR_RATES];
|
||||
+ u8 tmp_prob_rate = 0;
|
||||
u32 usecs;
|
||||
- u32 p;
|
||||
int i;
|
||||
|
||||
- mi->stats_update = jiffies;
|
||||
+ for (i=0; i < MAX_THR_RATES; i++)
|
||||
+ tmp_tp_rate[i] = 0;
|
||||
+
|
||||
for (i = 0; i < mi->n_rates; i++) {
|
||||
struct minstrel_rate *mr = &mi->r[i];
|
||||
|
||||
@@ -87,27 +101,32 @@ minstrel_update_stats(struct minstrel_pr
|
||||
if (!usecs)
|
||||
usecs = 1000000;
|
||||
|
||||
- /* To avoid rounding issues, probabilities scale from 0 (0%)
|
||||
- * to 18000 (100%) */
|
||||
- if (mr->attempts) {
|
||||
- p = (mr->success * 18000) / mr->attempts;
|
||||
+ if (unlikely(mr->attempts > 0)) {
|
||||
+ mr->sample_skipped = 0;
|
||||
+ mr->cur_prob = MINSTREL_FRAC(mr->success, mr->attempts);
|
||||
mr->succ_hist += mr->success;
|
||||
mr->att_hist += mr->attempts;
|
||||
- mr->cur_prob = p;
|
||||
- p = ((p * (100 - mp->ewma_level)) + (mr->probability *
|
||||
- mp->ewma_level)) / 100;
|
||||
- mr->probability = p;
|
||||
- mr->cur_tp = p * (1000000 / usecs);
|
||||
- }
|
||||
+ mr->probability = minstrel_ewma(mr->probability,
|
||||
+ mr->cur_prob,
|
||||
+ EWMA_LEVEL);
|
||||
+ } else
|
||||
+ mr->sample_skipped++;
|
||||
|
||||
mr->last_success = mr->success;
|
||||
mr->last_attempts = mr->attempts;
|
||||
mr->success = 0;
|
||||
mr->attempts = 0;
|
||||
|
||||
+ /* Update throughput per rate, reset thr. below 10% success */
|
||||
+ if (mr->probability < MINSTREL_FRAC(10, 100))
|
||||
+ mr->cur_tp = 0;
|
||||
+ else
|
||||
+ mr->cur_tp = mr->probability * (1000000 / usecs);
|
||||
+
|
||||
/* Sample less often below the 10% chance of success.
|
||||
* Sample less often above the 95% chance of success. */
|
||||
- if ((mr->probability > 17100) || (mr->probability < 1800)) {
|
||||
+ if (mr->probability > MINSTREL_FRAC(95, 100) ||
|
||||
+ mr->probability < MINSTREL_FRAC(10, 100)) {
|
||||
mr->adjusted_retry_count = mr->retry_count >> 1;
|
||||
if (mr->adjusted_retry_count > 2)
|
||||
mr->adjusted_retry_count = 2;
|
||||
@@ -118,35 +137,30 @@ minstrel_update_stats(struct minstrel_pr
|
||||
}
|
||||
if (!mr->adjusted_retry_count)
|
||||
mr->adjusted_retry_count = 2;
|
||||
- }
|
||||
|
||||
- for (i = 0; i < mi->n_rates; i++) {
|
||||
- struct minstrel_rate *mr = &mi->r[i];
|
||||
- if (max_tp < mr->cur_tp) {
|
||||
- index_max_tp = i;
|
||||
- max_tp = mr->cur_tp;
|
||||
- }
|
||||
- if (max_prob < mr->probability) {
|
||||
- index_max_prob = i;
|
||||
- max_prob = mr->probability;
|
||||
+ minstrel_sort_best_tp_rates(mi, i, tmp_tp_rate);
|
||||
+
|
||||
+ /* To determine the most robust rate (max_prob_rate) used at
|
||||
+ * 3rd mmr stage we distinct between two cases:
|
||||
+ * (1) if any success probabilitiy >= 95%, out of those rates
|
||||
+ * choose the maximum throughput rate as max_prob_rate
|
||||
+ * (2) if all success probabilities < 95%, the rate with
|
||||
+ * highest success probability is choosen as max_prob_rate */
|
||||
+ if (mr->probability >= MINSTREL_FRAC(95,100)) {
|
||||
+ if (mr->cur_tp >= mi->r[tmp_prob_rate].cur_tp)
|
||||
+ tmp_prob_rate = i;
|
||||
+ } else {
|
||||
+ if (mr->probability >= mi->r[tmp_prob_rate].probability)
|
||||
+ tmp_prob_rate = i;
|
||||
}
|
||||
}
|
||||
|
||||
- max_tp = 0;
|
||||
- for (i = 0; i < mi->n_rates; i++) {
|
||||
- struct minstrel_rate *mr = &mi->r[i];
|
||||
-
|
||||
- if (i == index_max_tp)
|
||||
- continue;
|
||||
+ /* Assign the new rate set */
|
||||
+ memcpy(mi->max_tp_rate, tmp_tp_rate, sizeof(mi->max_tp_rate));
|
||||
+ mi->max_prob_rate = tmp_prob_rate;
|
||||
|
||||
- if (max_tp < mr->cur_tp) {
|
||||
- index_max_tp2 = i;
|
||||
- max_tp = mr->cur_tp;
|
||||
- }
|
||||
- }
|
||||
- mi->max_tp_rate = index_max_tp;
|
||||
- mi->max_tp_rate2 = index_max_tp2;
|
||||
- mi->max_prob_rate = index_max_prob;
|
||||
+ /* Reset update timer */
|
||||
+ mi->stats_update = jiffies;
|
||||
}
|
||||
|
||||
static void
|
||||
@@ -207,10 +221,10 @@ static int
|
||||
minstrel_get_next_sample(struct minstrel_sta_info *mi)
|
||||
{
|
||||
unsigned int sample_ndx;
|
||||
- sample_ndx = SAMPLE_TBL(mi, mi->sample_idx, mi->sample_column);
|
||||
- mi->sample_idx++;
|
||||
- if ((int) mi->sample_idx > (mi->n_rates - 2)) {
|
||||
- mi->sample_idx = 0;
|
||||
+ sample_ndx = SAMPLE_TBL(mi, mi->sample_row, mi->sample_column);
|
||||
+ mi->sample_row++;
|
||||
+ if ((int) mi->sample_row >= mi->n_rates) {
|
||||
+ mi->sample_row = 0;
|
||||
mi->sample_column++;
|
||||
if (mi->sample_column >= SAMPLE_COLUMNS)
|
||||
mi->sample_column = 0;
|
||||
@@ -228,31 +242,37 @@ minstrel_get_rate(void *priv, struct iee
|
||||
struct minstrel_priv *mp = priv;
|
||||
struct ieee80211_tx_rate *ar = info->control.rates;
|
||||
unsigned int ndx, sample_ndx = 0;
|
||||
- bool mrr;
|
||||
- bool sample_slower = false;
|
||||
- bool sample = false;
|
||||
+ bool mrr_capable;
|
||||
+ bool indirect_rate_sampling = false;
|
||||
+ bool rate_sampling = false;
|
||||
int i, delta;
|
||||
int mrr_ndx[3];
|
||||
- int sample_rate;
|
||||
+ int sampling_ratio;
|
||||
|
||||
+ /* management/no-ack frames do not use rate control */
|
||||
if (rate_control_send_low(sta, priv_sta, txrc))
|
||||
return;
|
||||
|
||||
- mrr = mp->has_mrr && !txrc->rts && !txrc->bss_conf->use_cts_prot;
|
||||
-
|
||||
- ndx = mi->max_tp_rate;
|
||||
-
|
||||
- if (mrr)
|
||||
- sample_rate = mp->lookaround_rate_mrr;
|
||||
+ /* check multi-rate-retry capabilities & adjust lookaround_rate */
|
||||
+ mrr_capable = mp->has_mrr &&
|
||||
+ !txrc->rts &&
|
||||
+ !txrc->bss_conf->use_cts_prot;
|
||||
+ if (mrr_capable)
|
||||
+ sampling_ratio = mp->lookaround_rate_mrr;
|
||||
else
|
||||
- sample_rate = mp->lookaround_rate;
|
||||
+ sampling_ratio = mp->lookaround_rate;
|
||||
+
|
||||
+ /* init rateindex [ndx] with max throughput rate */
|
||||
+ ndx = mi->max_tp_rate[0];
|
||||
|
||||
+ /* increase sum packet counter */
|
||||
mi->packet_count++;
|
||||
- delta = (mi->packet_count * sample_rate / 100) -
|
||||
+
|
||||
+ delta = (mi->packet_count * sampling_ratio / 100) -
|
||||
(mi->sample_count + mi->sample_deferred / 2);
|
||||
|
||||
/* delta > 0: sampling required */
|
||||
- if ((delta > 0) && (mrr || !mi->prev_sample)) {
|
||||
+ if ((delta > 0) && (mrr_capable || !mi->prev_sample)) {
|
||||
struct minstrel_rate *msr;
|
||||
if (mi->packet_count >= 10000) {
|
||||
mi->sample_deferred = 0;
|
||||
@@ -271,21 +291,28 @@ minstrel_get_rate(void *priv, struct iee
|
||||
mi->sample_count += (delta - mi->n_rates * 2);
|
||||
}
|
||||
|
||||
+ /* get next random rate sample */
|
||||
sample_ndx = minstrel_get_next_sample(mi);
|
||||
msr = &mi->r[sample_ndx];
|
||||
- sample = true;
|
||||
- sample_slower = mrr && (msr->perfect_tx_time >
|
||||
- mi->r[ndx].perfect_tx_time);
|
||||
+ rate_sampling = true;
|
||||
|
||||
- if (!sample_slower) {
|
||||
+ /* Decide if direct ( 1st mrr stage) or indirect (2nd mrr stage)
|
||||
+ * rate sampling method should be used.
|
||||
+ * Respect such rates that are not sampled for 20 interations.
|
||||
+ */
|
||||
+ if (mrr_capable &&
|
||||
+ msr->perfect_tx_time > mi->r[ndx].perfect_tx_time &&
|
||||
+ msr->sample_skipped < 20)
|
||||
+ indirect_rate_sampling = true;
|
||||
+
|
||||
+ if (!indirect_rate_sampling) {
|
||||
if (msr->sample_limit != 0) {
|
||||
ndx = sample_ndx;
|
||||
mi->sample_count++;
|
||||
if (msr->sample_limit > 0)
|
||||
msr->sample_limit--;
|
||||
- } else {
|
||||
- sample = false;
|
||||
- }
|
||||
+ } else
|
||||
+ rate_sampling = false;
|
||||
} else {
|
||||
/* Only use IEEE80211_TX_CTL_RATE_CTRL_PROBE to mark
|
||||
* packets that have the sampling rate deferred to the
|
||||
@@ -297,34 +324,39 @@ minstrel_get_rate(void *priv, struct iee
|
||||
mi->sample_deferred++;
|
||||
}
|
||||
}
|
||||
- mi->prev_sample = sample;
|
||||
+ mi->prev_sample = rate_sampling;
|
||||
|
||||
/* If we're not using MRR and the sampling rate already
|
||||
* has a probability of >95%, we shouldn't be attempting
|
||||
* to use it, as this only wastes precious airtime */
|
||||
- if (!mrr && sample && (mi->r[ndx].probability > 17100))
|
||||
- ndx = mi->max_tp_rate;
|
||||
+ if (!mrr_capable && rate_sampling &&
|
||||
+ (mi->r[ndx].probability > MINSTREL_FRAC(95, 100)))
|
||||
+ ndx = mi->max_tp_rate[0];
|
||||
|
||||
+ /* mrr setup for 1st stage */
|
||||
ar[0].idx = mi->r[ndx].rix;
|
||||
ar[0].count = minstrel_get_retry_count(&mi->r[ndx], info);
|
||||
|
||||
- if (!mrr) {
|
||||
- if (!sample)
|
||||
+ /* non mrr setup for 2nd stage */
|
||||
+ if (!mrr_capable) {
|
||||
+ if (!rate_sampling)
|
||||
ar[0].count = mp->max_retry;
|
||||
ar[1].idx = mi->lowest_rix;
|
||||
ar[1].count = mp->max_retry;
|
||||
return;
|
||||
}
|
||||
|
||||
- /* MRR setup */
|
||||
- if (sample) {
|
||||
- if (sample_slower)
|
||||
+ /* mrr setup for 2nd stage */
|
||||
+ if (rate_sampling) {
|
||||
+ if (indirect_rate_sampling)
|
||||
mrr_ndx[0] = sample_ndx;
|
||||
else
|
||||
- mrr_ndx[0] = mi->max_tp_rate;
|
||||
+ mrr_ndx[0] = mi->max_tp_rate[0];
|
||||
} else {
|
||||
- mrr_ndx[0] = mi->max_tp_rate2;
|
||||
+ mrr_ndx[0] = mi->max_tp_rate[1];
|
||||
}
|
||||
+
|
||||
+ /* mrr setup for 3rd & 4th stage */
|
||||
mrr_ndx[1] = mi->max_prob_rate;
|
||||
mrr_ndx[2] = 0;
|
||||
for (i = 1; i < 4; i++) {
|
||||
@@ -351,26 +383,21 @@ static void
|
||||
init_sample_table(struct minstrel_sta_info *mi)
|
||||
{
|
||||
unsigned int i, col, new_idx;
|
||||
- unsigned int n_srates = mi->n_rates - 1;
|
||||
u8 rnd[8];
|
||||
|
||||
mi->sample_column = 0;
|
||||
- mi->sample_idx = 0;
|
||||
- memset(mi->sample_table, 0, SAMPLE_COLUMNS * mi->n_rates);
|
||||
+ mi->sample_row = 0;
|
||||
+ memset(mi->sample_table, 0xff, SAMPLE_COLUMNS * mi->n_rates);
|
||||
|
||||
for (col = 0; col < SAMPLE_COLUMNS; col++) {
|
||||
- for (i = 0; i < n_srates; i++) {
|
||||
+ for (i = 0; i < mi->n_rates; i++) {
|
||||
get_random_bytes(rnd, sizeof(rnd));
|
||||
- new_idx = (i + rnd[i & 7]) % n_srates;
|
||||
+ new_idx = (i + rnd[i & 7]) % mi->n_rates;
|
||||
|
||||
- while (SAMPLE_TBL(mi, new_idx, col) != 0)
|
||||
- new_idx = (new_idx + 1) % n_srates;
|
||||
+ while (SAMPLE_TBL(mi, new_idx, col) != 0xff)
|
||||
+ new_idx = (new_idx + 1) % mi->n_rates;
|
||||
|
||||
- /* Don't sample the slowest rate (i.e. slowest base
|
||||
- * rate). We must presume that the slowest rate works
|
||||
- * fine, or else other management frames will also be
|
||||
- * failing and the link will break */
|
||||
- SAMPLE_TBL(mi, new_idx, col) = i + 1;
|
||||
+ SAMPLE_TBL(mi, new_idx, col) = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -542,9 +569,6 @@ minstrel_alloc(struct ieee80211_hw *hw,
|
||||
mp->lookaround_rate = 5;
|
||||
mp->lookaround_rate_mrr = 10;
|
||||
|
||||
- /* moving average weight for EWMA */
|
||||
- mp->ewma_level = 75;
|
||||
-
|
||||
/* maximum time that the hw is allowed to stay in one MRR segment */
|
||||
mp->segment_size = 6000;
|
||||
|
||||
--- a/net/mac80211/rc80211_minstrel.h
|
||||
+++ b/net/mac80211/rc80211_minstrel.h
|
||||
@@ -9,6 +9,28 @@
|
||||
#ifndef __RC_MINSTREL_H
|
||||
#define __RC_MINSTREL_H
|
||||
|
||||
+#define EWMA_LEVEL 75 /* ewma weighting factor [%] */
|
||||
+#define SAMPLE_COLUMNS 10 /* number of columns in sample table */
|
||||
+
|
||||
+
|
||||
+/* scaled fraction values */
|
||||
+#define MINSTREL_SCALE 16
|
||||
+#define MINSTREL_FRAC(val, div) (((val) << MINSTREL_SCALE) / div)
|
||||
+#define MINSTREL_TRUNC(val) ((val) >> MINSTREL_SCALE)
|
||||
+
|
||||
+/* number of highest throughput rates to consider*/
|
||||
+#define MAX_THR_RATES 4
|
||||
+
|
||||
+/*
|
||||
+ * Perform EWMA (Exponentially Weighted Moving Average) calculation
|
||||
+ */
|
||||
+static inline int
|
||||
+minstrel_ewma(int old, int new, int weight)
|
||||
+{
|
||||
+ return (new * (100 - weight) + old * weight) / 100;
|
||||
+}
|
||||
+
|
||||
+
|
||||
struct minstrel_rate {
|
||||
int bitrate;
|
||||
int rix;
|
||||
@@ -26,6 +48,7 @@ struct minstrel_rate {
|
||||
u32 attempts;
|
||||
u32 last_attempts;
|
||||
u32 last_success;
|
||||
+ u8 sample_skipped;
|
||||
|
||||
/* parts per thousand */
|
||||
u32 cur_prob;
|
||||
@@ -45,14 +68,13 @@ struct minstrel_sta_info {
|
||||
|
||||
unsigned int lowest_rix;
|
||||
|
||||
- unsigned int max_tp_rate;
|
||||
- unsigned int max_tp_rate2;
|
||||
- unsigned int max_prob_rate;
|
||||
+ u8 max_tp_rate[MAX_THR_RATES];
|
||||
+ u8 max_prob_rate;
|
||||
unsigned int packet_count;
|
||||
unsigned int sample_count;
|
||||
int sample_deferred;
|
||||
|
||||
- unsigned int sample_idx;
|
||||
+ unsigned int sample_row;
|
||||
unsigned int sample_column;
|
||||
|
||||
int n_rates;
|
||||
@@ -73,7 +95,6 @@ struct minstrel_priv {
|
||||
unsigned int cw_min;
|
||||
unsigned int cw_max;
|
||||
unsigned int max_retry;
|
||||
- unsigned int ewma_level;
|
||||
unsigned int segment_size;
|
||||
unsigned int update_interval;
|
||||
unsigned int lookaround_rate;
|
||||
--- a/net/mac80211/rc80211_minstrel_debugfs.c
|
||||
+++ b/net/mac80211/rc80211_minstrel_debugfs.c
|
||||
@@ -73,15 +73,17 @@ minstrel_stats_open(struct inode *inode,
|
||||
for (i = 0; i < mi->n_rates; i++) {
|
||||
struct minstrel_rate *mr = &mi->r[i];
|
||||
|
||||
- *(p++) = (i == mi->max_tp_rate) ? 'T' : ' ';
|
||||
- *(p++) = (i == mi->max_tp_rate2) ? 't' : ' ';
|
||||
+ *(p++) = (i == mi->max_tp_rate[0]) ? 'A' : ' ';
|
||||
+ *(p++) = (i == mi->max_tp_rate[1]) ? 'B' : ' ';
|
||||
+ *(p++) = (i == mi->max_tp_rate[2]) ? 'C' : ' ';
|
||||
+ *(p++) = (i == mi->max_tp_rate[3]) ? 'D' : ' ';
|
||||
*(p++) = (i == mi->max_prob_rate) ? 'P' : ' ';
|
||||
p += sprintf(p, "%3u%s", mr->bitrate / 2,
|
||||
(mr->bitrate & 1 ? ".5" : " "));
|
||||
|
||||
- tp = mr->cur_tp / ((18000 << 10) / 96);
|
||||
- prob = mr->cur_prob / 18;
|
||||
- eprob = mr->probability / 18;
|
||||
+ tp = MINSTREL_TRUNC(mr->cur_tp / 10);
|
||||
+ prob = MINSTREL_TRUNC(mr->cur_prob * 1000);
|
||||
+ eprob = MINSTREL_TRUNC(mr->probability * 1000);
|
||||
|
||||
p += sprintf(p, " %6u.%1u %6u.%1u %6u.%1u "
|
||||
"%3u(%3u) %8llu %8llu\n",
|
||||
|
|
|
|||
Loading…
Reference in New Issue