sch_red: Adaptative RED AQM

Adaptative RED AQM for linux, based on paper from Sally FLoyd,
Ramakrishna Gummadi, and Scott Shenker, August 2001 :

http://icir.org/floyd/papers/adaptiveRed.pdf

Goal of Adaptative RED is to make max_p a dynamic value between 1% and
50% to reach the target average queue : (max_th - min_th) / 2

Every 500 ms:
 if (avg > target and max_p <= 0.5)
  increase max_p : max_p += alpha;
 else if (avg < target and max_p >= 0.01)
  decrease max_p : max_p *= beta;

target :[min_th + 0.4*(min_th - max_th),
          min_th + 0.6*(min_th - max_th)].
alpha : min(0.01, max_p / 4)
beta : 0.9
max_P is a Q0.32 fixed point number (unsigned, with 32 bits mantissa)

Changes against our RED implementation are :

max_p is no longer a negative power of two (1/(2^Plog)), but a Q0.32
fixed point number, to allow full range described in Adatative paper.

To deliver a random number, we now use a reciprocal divide (thats really
a multiply), but this operation is done once per marked/droped packet
when in RED_BETWEEN_TRESH window, so added cost (compared to previous
AND operation) is near zero.

dump operation gives current max_p value in a new TCA_RED_MAX_P
attribute.

Example on a 10Mbit link :

tc qdisc add dev $DEV parent 1:1 handle 10: est 1sec 8sec red \
   limit 400000 min 30000 max 90000 avpkt 1000 \
   burst 55 ecn adaptative bandwidth 10Mbit

# tc -s -d qdisc show dev eth3
...
qdisc red 10: parent 1:1 limit 400000b min 30000b max 90000b ecn
adaptative ewma 5 max_p=0.113335 Scell_log 15
 Sent 50414282 bytes 34504 pkt (dropped 35, overlimits 1392 requeues 0)
 rate 9749Kbit 831pps backlog 72056b 16p requeues 0
  marked 1357 early 35 pdrop 0 other 0

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 21 insertions, 0 deletions

diff --git a/net/sched/sch_red.c b/net/sched/sch_red.c
index d617161f8dd3..8f5a85bf9d10 100644
--- a/net/sched/sch_red.c
+++ b/net/sched/sch_red.c
@@ -39,6 +39,7 @@
 struct red_sched_data {
         u32                     limit;          /* HARD maximal queue length */
         unsigned char           flags;
+        struct timer_list       adapt_timer;
         struct red_parms        parms;
         struct red_stats        stats;
         struct Qdisc            *qdisc;
@@ -161,6 +162,8 @@ static void red_reset(struct Qdisc *sch)
 static void red_destroy(struct Qdisc *sch)
 {
         struct red_sched_data *q = qdisc_priv(sch);
+
+        del_timer_sync(&q->adapt_timer);
         qdisc_destroy(q->qdisc);
 }
 
@@ -209,6 +212,10 @@ static int red_change(struct Qdisc *sch, struct nlattr *opt)
                                  ctl->Plog, ctl->Scell_log,
                                  nla_data(tb[TCA_RED_STAB]));
 
+        del_timer(&q->adapt_timer);
+        if (ctl->flags & TC_RED_ADAPTATIVE)
+                mod_timer(&q->adapt_timer, jiffies + HZ/2);
+
         if (!q->qdisc->q.qlen)
                 red_start_of_idle_period(&q->parms);
 
@@ -216,11 +223,24 @@ static int red_change(struct Qdisc *sch, struct nlattr *opt)
         return 0;
 }
 
+static inline void red_adaptative_timer(unsigned long arg)
+{
+        struct Qdisc *sch = (struct Qdisc *)arg;
+        struct red_sched_data *q = qdisc_priv(sch);
+        spinlock_t *root_lock = qdisc_lock(qdisc_root_sleeping(sch));
+
+        spin_lock(root_lock);
+        red_adaptative_algo(&q->parms);
+        mod_timer(&q->adapt_timer, jiffies + HZ/2);
+        spin_unlock(root_lock);
+}
+
 static int red_init(struct Qdisc *sch, struct nlattr *opt)
 {
         struct red_sched_data *q = qdisc_priv(sch);
 
         q->qdisc = &noop_qdisc;
+        setup_timer(&q->adapt_timer, red_adaptative_timer, (unsigned long)sch);
         return red_change(sch, opt);
 }
 
@@ -243,6 +263,7 @@ static int red_dump(struct Qdisc *sch, struct sk_buff *skb)
         if (opts == NULL)
                 goto nla_put_failure;
         NLA_PUT(skb, TCA_RED_PARMS, sizeof(opt), &opt);
+        NLA_PUT_U32(skb, TCA_RED_MAX_P, q->parms.max_P);
         return nla_nest_end(skb, opts);
 
 nla_put_failure: