net-qdisc-hhf: Heavy-Hitter Filter (HHF) qdisc
Subsystems (3)
PATCH 1/1 net-qdisc-hhf: Heavy-Hitter Filter (HHF) qdisc
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.
Some configurable qdisc settings through 'tc':
- hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
- hhf_admit_bytes: threshold to classify heavy-hitters
(default 128KB)
- hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
- hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
- hh_flows_limit: max number of heavy-hitter flow entries
(default 2048)
Note that the ratio between hhf_admit_bytes and hhf_reset_timeout reflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).
The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.c
include/uapi/linux/pkt_sched.h +25 -0
@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif
net/sched/Kconfig +9 -0
@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACT
net/sched/Makefile +1 -0
@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.o
net/sched/sch_hhf.c new file +746 -0
746 lines not on this page · raw message
Signature · 1 line
1.8.5.1
Quoted 71 lines · On Tue, 10 Dec 2013 23:26:36 -0800 Terry Lam <[email protected]> wrote:
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +11
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows;__u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT ,
include/uapi/linux/pkt_sched.h struct tc_fq_qd_stats { · line 813
Quoted 10 lines
include/uapi/linux/pkt_sched.h +10
-0+ TCA_HHF_NON_HH_WEIGHT, + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/
64 bit?
Quoted 14 lines
include/uapi/linux/pkt_sched.h +4
-0+__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ + __u32 hh_cur_count; /* number of current heavy-hitters */ +};#endif net/sched/sch_hhf.c new file +0
-0
net/sched/sch_hhf.c line 110
Quoted 3 lines
net/sched/sch_hhf.c new file +2
-0@@ -0,0 +1,746 @@ +#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0))
Why reinvent time_before?
Quoted 57 lines
net/sched/sch_hhf.c new file +57
-0+ +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/
net/sched/sch_hhf.c line 177
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/ +}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +}
Why wrap jiffies needlessly
Quoted 5 lines
net/sched/sch_hhf.c new file +5
-0+static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash;
net/sched/sch_hhf.c line 193
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+ +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; + +skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +}
Why not reuse flow dissect logic that exists in SFQ?
net/sched/sch_hhf.c line 198
Quoted 4 lines
net/sched/sch_hhf.c new file +4
-0+/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q)
Don't use inline. Let compiler decide.
Quoted 144 lines
net/sched/sch_hhf.c new file +144
-0+{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +}
net/sched/sch_hhf.c line 352
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+ +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head; + + bucket->head = skb->next; + skb->next =NULL ; +return skb; +}
Seems like reinvention of sk_list??
Quoted 131 lines
net/sched/sch_hhf.c new file +131
-0+ +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +}
net/sched/sch_hhf.c line 493
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+ +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); + +if (!ptr) + ptr =vzalloc (sz); + +return ptr; +}
Are you really allocating thing so big that kmalloc fails? If so, please base it on size > PAGE_SIZE
Quoted 187 lines · Stephen Hemminger
Quoted 71 lines · On Tue, 10 Dec 2013 23:26:36 -0800 Terry Lam <[email protected]> wrote:
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +11
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows;__u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT ,include/uapi/linux/pkt_sched.h struct tc_fq_qd_stats { · line 813
Quoted 10 lines
include/uapi/linux/pkt_sched.h +10
-0+ TCA_HHF_NON_HH_WEIGHT, + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ 64 bit?
Quoted 14 lines
include/uapi/linux/pkt_sched.h +4
-0+__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ + __u32 hh_cur_count; /* number of current heavy-hitters */ +};#endif net/sched/sch_hhf.c new file +0
-0net/sched/sch_hhf.c line 110
Quoted 3 lines
net/sched/sch_hhf.c new file +2
-0@@ -0,0 +1,746 @@ +#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0))Why reinvent
time_before?Quoted 57 lines
net/sched/sch_hhf.c new file +57
-0+ +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/ net/sched/sch_hhf.c line 177
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/ +}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +}Why wrap jiffies needlessly
Quoted 9 lines
net/sched/sch_hhf.c new file +9
-0+static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash; + +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; +
Quoted 9 lines
net/sched/sch_hhf.c line 193
Quoted 6 lines
net/sched/sch_hhf.c new file +6
-0+skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +}Why not reuse flow dissect logic that exists in SFQ?
This could be a library function to to get the "txhash" for an skb, most of it should also be in a common function with __skb_get_rxhash. Does not applying the perturbation in the case of a hash in the socket cause a loss of functionality?
Quoted 313 lines
net/sched/sch_hhf.c line 198
Quoted 5 lines
net/sched/sch_hhf.c new file +4
-0+/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q)Don't use inline. Let compiler decide.
Quoted 144 lines
net/sched/sch_hhf.c new file +144
-0+{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +}net/sched/sch_hhf.c line 352
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+ +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head; + + bucket->head = skb->next; + skb->next =NULL ; +return skb; +}Seems like reinvention of
sk_list??Quoted 131 lines
net/sched/sch_hhf.c new file +131
-0+ +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +}net/sched/sch_hhf.c line 493
Quoted 10 lines
net/sched/sch_hhf.c new file +10
-0+ +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); + +if (!ptr) + ptr =vzalloc (sz); + +return ptr; +}Are you really allocating thing so big that kmalloc fails? If so, please base it on size >
PAGE_SIZE
--
To unsubscribe from this list: send the line "unsubscribe netdev" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Thanks for the quick review! See my inline comments.
Quoted 80 lines · Tom Herbert
Quoted 78 lines · Stephen Hemminger
Quoted 75 lines · On Tue, 10 Dec 2013 23:26:36 -0800 Terry Lam <[email protected]> wrote:
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +15
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows;__u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; +
Quoted 8 lines
Quoted 8 lines
include/uapi/linux/pkt_sched.h struct tc_fq_qd_stats { · line 813
Quoted 6 lines
include/uapi/linux/pkt_sched.h +6
-0+#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ 64 bit?
Since drop_overlimit counts the packets being tail-dropped, I think 32-bit is sufficient and this is also similar to other places (eg. struct gnet_stats_queue). Let me know if you think otherwise.
Quoted 15 lines
Quoted 15 lines
Quoted 14 lines
include/uapi/linux/pkt_sched.h +4
-0+__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ + __u32 hh_cur_count; /* number of current heavy-hitters */ +};#endif net/sched/sch_hhf.c new file +0
-0@@ -0,0 +1,746 @@
Quoted 4 lines
Quoted 4 lines
net/sched/sch_hhf.c line 110
Quoted 2 lines
net/sched/sch_hhf.c new file +2
-0+#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0))Why reinvent
time_before?
Done. Replaced with time_before.
Quoted 61 lines
Quoted 61 lines
Quoted 61 lines
net/sched/sch_hhf.c new file +61
-0+ +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/ +u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/
Quoted 8 lines
Quoted 8 lines
net/sched/sch_hhf.c line 177
Quoted 6 lines
net/sched/sch_hhf.c new file +6
-0+}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +}Why wrap jiffies needlessly
Similar rationale for "inet_tw_time_stamp()" as in
http://patchwork.ozlabs.org/patch/280436/
Quoted 19 lines
Quoted 10 lines
Quoted 10 lines
net/sched/sch_hhf.c new file +9
-0+static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash; + +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; +Quoted 9 lines
net/sched/sch_hhf.c line 193
Quoted 6 lines
net/sched/sch_hhf.c new file +6
-0+skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +}Why not reuse flow dissect logic that exists in SFQ?
Quoted 5 lines
This could be a library function to to get the "txhash" for an skb, most of it should also be in a common function with
__skb_get_rxhash. Does not applying the perturbation in the case of a hash in the socket cause a loss of functionality?
This is indeed similar logic to fq_codel, but note that here we need the full hash value (i.e. without applying modulo the number of divisors/buckets as in sfq/fq_codel).
I agree that this could be a "txhash" library. I think we do need perturbation for security, i.e. avoiding on-purpose hash collision. Also the correctness of the multistage filter algorithm is on the basis of true hashing randomness.
Quoted 8 lines
Quoted 8 lines
net/sched/sch_hhf.c line 198
Quoted 5 lines
net/sched/sch_hhf.c new file +4
-0+/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q)Don't use inline. Let compiler decide.
Done.
Quoted 149 lines
Quoted 149 lines
Quoted 149 lines
net/sched/sch_hhf.c new file +149
-0+{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +} + +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head;
Quoted 8 lines
Quoted 8 lines
net/sched/sch_hhf.c line 352
Quoted 5 lines
net/sched/sch_hhf.c new file +5
-0+ + bucket->head = skb->next; + skb->next =NULL ; +return skb; +}Seems like reinvention of
sk_list??
A bucket contains a deficit value and a list of skbs -- this is similar to how the skb list is handled in sfq, fq and fq_codel.
Quoted 136 lines
Quoted 136 lines
Quoted 136 lines
net/sched/sch_hhf.c new file +136
-0+ +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +} + +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); +
Quoted 8 lines
Quoted 8 lines
net/sched/sch_hhf.c line 493
Quoted 5 lines
net/sched/sch_hhf.c new file +5
-0+if (!ptr) + ptr =vzalloc (sz); + +return ptr; +}Are you really allocating thing so big that kmalloc fails? If so, please base it on size >
PAGE_SIZE
As explained in the file comments, we need to allocate 16KB for table T and 16KB for filter arrays F. This is about the same scale with fq_codel, so I reuse the way fq_codel allocates memory. But since kmalloc should not fail in this case, do you suggest to omit vzalloc?
PATCH v2 1/1 net-qdisc-hhf: Heavy-Hitter Filter (HHF) qdisc
In reply to Terry LamThis patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.
Some configurable qdisc settings through 'tc':
- hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
- hhf_admit_bytes: threshold to classify heavy-hitters
(default 128KB)
- hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
- hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
- hh_flows_limit: max number of heavy-hitter flow entries
(default 2048)
Note that the ratio between hhf_admit_bytes and hhf_reset_timeout reflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).
The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
---
Changelog since v1:
- Use time_before and no explicit inline
include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 744 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 779 insertions(+) create mode 100644 net/sched/sch_hhf.c
include/uapi/linux/pkt_sched.h +25 -0
@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif
net/sched/Kconfig +9 -0
@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACT
net/sched/Makefile +1 -0
@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.o
net/sched/sch_hhf.c new file +744 -0
744 lines not on this page · raw message
Signature · 1 line
1.8.5.1
net/sched/sch_hhf.c line 174
Quoted 4 lines · Terry Lam
net/sched/sch_hhf.c new file +4
-0+static u32 hhf_time_stamp (void ) +{ +return jiffies; +}
This is a 32 bit value (For a good reason)
net/sched/sch_hhf.c line 198
Quoted 3 lines
net/sched/sch_hhf.c new file +3
-0+{ +struct hh_flow_state *flow, *next; +unsigned long now =hhf_time_stamp ();
stored in a 'unsigned long'
net/sched/sch_hhf.c line 204
Quoted 6 lines
net/sched/sch_hhf.c new file +6
-0+ +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +unsigned long prev = flow->hit_timestamp + q->hhf_evict_timeout;
32bit + ...
Review
Quoted 2 lines
(quoted diff) +2
-0+ + if (time_before(prev, now)) {
This wont work on 64 bit arches : Wrapping wont be detected anymore.
We keep 32bit variables to lower memory usage, this is why we have special macros in include/net/codel.h
Please make sure you test your v3 patch, there is no hurry ;)
Thanks !
Quoted 29 lines · Eric Dumazet
net/sched/sch_hhf.c line 174
Quoted 4 lines · Terry Lam
net/sched/sch_hhf.c new file +4
-0+static u32 hhf_time_stamp (void ) +{ +return jiffies; +}This is a 32 bit value (For a good reason)
net/sched/sch_hhf.c line 198
Quoted 3 lines
net/sched/sch_hhf.c new file +3
-0+{ +struct hh_flow_state *flow, *next; +unsigned long now =hhf_time_stamp ();stored in a 'unsigned long'
net/sched/sch_hhf.c line 204
Quoted 6 lines
net/sched/sch_hhf.c new file +6
-0+ +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +unsigned long prev = flow->hit_timestamp + q->hhf_evict_timeout;32bit + ...
Review
Quoted 2 lines
(quoted diff) +2
-0+ + if (time_before(prev, now)) {
Quoted 7 lines
This wont work on 64 bit arches : Wrapping wont be detected anymore.
We keep 32bit variables to lower memory usage, this is why we have special macros in
include/net/codel.hPlease make sure you test your v3 patch, there is no hurry ;)
Thanks for spotting out this, Eric! time_before() needs an "unsigned long" to avoid compile warning and I was confused by the existence of both time_before() and time_before64() in jiffies.h.
I agree we should keep 32bit to save memory, so the best solution here is to put back hhf_time_before() definition.
PATCH v3 1/1 net-qdisc-hhf: Heavy-Hitter Filter (HHF) qdisc
In reply to Terry LamThis patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.
Some configurable qdisc settings through 'tc':
- hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
- hhf_admit_bytes: threshold to classify heavy-hitters
(default 128KB)
- hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
- hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
- hh_flows_limit: max number of heavy-hitter flow entries
(default 2048)
Note that the ratio between hhf_admit_bytes and hhf_reset_timeout reflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).
The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
---
Changelog since v2:
- With u32 timestamp (to save memory), standard time_before() does not work, so we need hhf_time_before(). Also re-test with netperf that HHF can improve mice latency (eg 10X with 200 bulk flows on 10G link).
Changelog since v1:
- Use time_before and no explicit inline
include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.c
include/uapi/linux/pkt_sched.h +25 -0
@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif
net/sched/Kconfig +9 -0
@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACT
net/sched/Makefile +1 -0
@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.o
net/sched/sch_hhf.c new file +746 -0
746 lines not on this page · raw message
Signature · 1 line
1.8.5.1
David Miller
maintainerFrom: Terry Lam <[email protected]>
Date: Sun, 15 Dec 2013 00:30:21 -0800
Quoted 6 lines
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
Can someone please review this, thanks!
Eric Dumazet
Acked-byQuoted 11 lines · David Miller
From: Terry Lam <[email protected]>
Date: Sun, 15 Dec 2013 00:30:21 -0800Quoted 6 lines
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
Can someone please review this, thanks!
I did, and somehow managed to not send the message :
Thanks !
From: Eric Dumazet <[email protected]>
Date: Thu, 19 Dec 2013 11:40:36 -0800
Quoted 11 lines · David Miller
Quoted 10 lines
From: Terry Lam <[email protected]>
Date: Sun, 15 Dec 2013 00:30:21 -0800Quoted 6 lines
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
Quoted 6 lines
Quoted 1 line
Can someone please review this, thanks!
I did, and somehow managed to not send the message :
Acked-by Eric Dumazet <[email protected]>
Applied, thanks everyone.
Quoted 53 lines · On Sun, 15 Dec 2013 00:30:21 -0800 Terry Lam <[email protected]> wrote:
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>---
Changelog since v2:
- With u32 timestamp (to save memory), standardtime_before()does not work, so we needhhf_time_before(). Also re-test with netperf that HHF can improve mice latency (eg 10X with 200 bulk flows on 10G link).Changelog since v1:
- Usetime_beforeand no explicit inline
Quoted 6 lines
include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.c
Please post the iproute2 changes as well...
Terry,
HHF defines it's own skb_hash function. Do you see any issues if we remove this and call skb_get_hash instead. We'll have functionality in TX to set skb->hash from sk_hash. The only difference is that in non-connected socket case we won't include q->perturbation in the jhash-- how important is this?
Quoted 877 lines · Terry Lam
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +25
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif net/sched/Kconfig +9
-0@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACTnet/sched/Makefile +1
-0@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.onet/sched/sch_hhf.c new file +746
-1@@ -0,0 +1,746 @@ +/* net/sched/sch_hhf.c Heavy-Hitter Filter (HHF) +* +* Copyright (C) 2013 Terry Lam <[email protected]> +* Copyright (C) 2013 Nandita Dukkipati <[email protected]> +*/ + +#include <linux/jhash.h> +#include <linux/jiffies.h> +#include <linux/module.h> +#include <linux/skbuff.h> +#include <linux/vmalloc.h> +#include <net/flow_keys.h> +#include <net/pkt_sched.h> +#include <net/sock.h> + +/* Heavy-Hitter Filter (HHF) +* +* Principles : +* Flows are classified into two buckets: non-heavy-hitter and heavy-hitter +* buckets. Initially, a new flow starts as non-heavy-hitter. Once classified +* as heavy-hitter, it is immediately switched to the heavy-hitter bucket. +* The buckets are dequeued by a Weighted Deficit Round Robin (WDRR) scheduler, +* in which the heavy-hitter bucket is served with less weight. +* In other words, non-heavy-hitters (e.g., short bursts of critical traffic) +* are isolated from heavy-hitters (e.g., persistent bulk traffic) and also have +* higher share of bandwidth. +* +* To capture heavy-hitters, we use the "multi-stage filter" algorithm in the +* following paper: +* [EV02] C. Estan and G. Varghese, "New Directions in Traffic Measurement and +* Accounting", in ACM SIGCOMM, 2002. +* +* Conceptually, a multi-stage filter comprises k independent hash functions +* and k counter arrays. Packets are indexed into k counter arrays by k hash +* functions, respectively. The counters are then increased by the packet sizes. +* Therefore, +* - For a heavy-hitter flow: *all* of its k array counters must be large. +* - For a non-heavy-hitter flow: some of its k array counters can be large +* due to hash collision with other small flows; however, with high +* probability, not *all* k counters are large. +* +* By the design of the multi-stage filter algorithm, the false negative rate +* (heavy-hitters getting away uncaptured) is zero. However, the algorithm is +* susceptible to false positives (non-heavy-hitters mistakenly classified as +* heavy-hitters). +* Therefore, we also implement the following optimizations to reduce false +* positives by avoiding unnecessary increment of the counter values: +* - Optimization O1: once a heavy-hitter is identified, its bytes are not +* accounted in the array counters. This technique is called "shielding" +* in Section 3.3.1 of [EV02]. +* - Optimization O2: conservative update of counters +* (Section 3.3.2 of [EV02]), +* New counter value = max {old counter value, +* smallest counter value + packet bytes} +* +* Finally, we refresh the counters periodically since otherwise the counter +* values will keep accumulating. +* +* Once a flow is classified as heavy-hitter, we also save its per-flow state +* in an exact-matching flow table so that its subsequent packets can be +* dispatched to the heavy-hitter bucket accordingly. +* +* +* At a high level, this qdisc works as follows: +* Given a packet p: +* - If the flow-id of p (e.g., TCP 5-tuple) is already in the exact-matching +* heavy-hitter flow table, denoted table T, then send p to the heavy-hitter +* bucket. +* - Otherwise, forward p to the multi-stage filter, denoted filter F +* + If F decides that p belongs to a non-heavy-hitter flow, then send p +* to the non-heavy-hitter bucket. +* + Otherwise, if F decides that p belongs to a new heavy-hitter flow, +* then set up a new flow entry for the flow-id of p in the table T and +* send p to the heavy-hitter bucket. +* +* In this implementation: +* - T is a fixed-size hash-table with 1024 entries. Hash collision is +* resolved by linked-list chaining. +* - F has four counter arrays, each array containing 1024 32-bit counters. +* That means 4 * 1024 * 32 bits = 16KB of memory. +* - Since each array in F contains 1024 counters, 10 bits are sufficient to +* index into each array. +* Hence, instead of having four hash functions, we chop the 32-bit +* skb-hash into three 10-bit chunks, and the remaining 10-bit chunk is +* computed as XOR sum of those three chunks. +* - We need to clear the counter arrays periodically; however, directly +* memsetting 16KB of memory can lead to cache eviction and unwanted delay. +* So by representing each counter by a valid bit, we only need to reset +* 4K of 1 bit (i.e. 512 bytes) instead of 16KB of memory. +* - The Deficit Round Robin engine is taken from fq_codel implementation +* (net/sched/sch_fq_codel.c). Note that wdrr_bucket corresponds to +* fq_codel_flow in fq_codel implementation. +* +*/ + +/* Non-configurable parameters */ +#define HH_FLOWS_CNT 1024/* number of entries in exact-matching table T */ +#define HHF_ARRAYS_CNT 4/* number of arrays in multi-stage filter F */ +#define HHF_ARRAYS_LEN 1024/* number of counters in each array of F */ +#define HHF_BIT_MASK_LEN 10/* masking 10 bits */ +#define HHF_BIT_MASK 0x3FF/* bitmask of 10 bits */ + +#define WDRR_BUCKET_CNT 2/* two buckets for Weighted DRR */ +enum wdrr_bucket_idx { +WDRR_BUCKET_FOR_HH =0 ,/* bucket id for heavy-hitters */ +WDRR_BUCKET_FOR_NON_HH =1 /* bucket id for non-heavy-hitters */ +}; + +#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0)) + +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/ +u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/ +}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +} + +static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash; + +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; + +skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +} + +/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +} + +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head; + + bucket->head = skb->next; + skb->next =NULL ; +return skb; +} + +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +} + +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); + +if (!ptr) + ptr =vzalloc (sz); + +return ptr; +} + +static void hhf_free (void *addr) +{ +if (addr) { +if (is_vmalloc_addr (addr)) +vfree (addr); +else +kfree (addr); + } +} + +static void hhf_destroy (struct Qdisc *sch) +{ +int i; +struct hhf_sched_data *q =qdisc_priv (sch); + +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +hhf_free (q->hhf_arrays[i]); +hhf_free (q->hhf_valid_bits[i]); + } + +for (i =0 ; i <HH_FLOWS_CNT ; i++) { +struct hh_flow_state *flow, *next; +struct list_head *head = &q->hh_flows[i]; + +if (list_empty (head)) +continue ; +list_for_each_entry_safe (flow, next, head, flowchain) { +list_del (&flow->flowchain); +kfree (flow); + } + } +hhf_free (q->hh_flows); +} + +static const struct nla_policy hhf_policy[TCA_HHF_MAX +1 ] = { + [TCA_HHF_BACKLOG_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_QUANTUM ] = { .type =NLA_U32 }, + [TCA_HHF_HH_FLOWS_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_RESET_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_ADMIT_BYTES ] = { .type =NLA_U32 }, + [TCA_HHF_EVICT_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_NON_HH_WEIGHT ] = { .type =NLA_U32 }, +}; + +static int hhf_change (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *tb[TCA_HHF_MAX +1 ]; +unsigned int qlen; +int err; +u64 non_hh_quantum; +u32 new_quantum = q->quantum; +u32 new_hhf_non_hh_weight = q->hhf_non_hh_weight; + +if (!opt) +return -EINVAL ; + + err =nla_parse_nested (tb,TCA_HHF_MAX , opt, hhf_policy); +if (err <0 ) +return err; + +sch_tree_lock (sch); + +if (tb[TCA_HHF_BACKLOG_LIMIT ]) + sch->limit =nla_get_u32 (tb[TCA_HHF_BACKLOG_LIMIT ]); + +if (tb[TCA_HHF_QUANTUM ]) + new_quantum =nla_get_u32 (tb[TCA_HHF_QUANTUM ]); + +if (tb[TCA_HHF_NON_HH_WEIGHT ]) + new_hhf_non_hh_weight =nla_get_u32 (tb[TCA_HHF_NON_HH_WEIGHT ]); + + non_hh_quantum = (u64 )new_quantum * new_hhf_non_hh_weight; +if (non_hh_quantum >INT_MAX ) +return -EINVAL ; + q->quantum = new_quantum; + q->hhf_non_hh_weight = new_hhf_non_hh_weight; + +if (tb[TCA_HHF_HH_FLOWS_LIMIT ]) + q->hh_flows_limit =nla_get_u32 (tb[TCA_HHF_HH_FLOWS_LIMIT ]); + +if (tb[TCA_HHF_RESET_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_RESET_TIMEOUT ]); + + q->hhf_reset_timeout =msecs_to_jiffies (ms); + } + +if (tb[TCA_HHF_ADMIT_BYTES ]) + q->hhf_admit_bytes =nla_get_u32 (tb[TCA_HHF_ADMIT_BYTES ]); + +if (tb[TCA_HHF_EVICT_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_EVICT_TIMEOUT ]); + + q->hhf_evict_timeout =msecs_to_jiffies (ms); + } + + qlen = sch->q.qlen; +while (sch->q.qlen > sch->limit) { +struct sk_buff *skb =hhf_dequeue (sch); + +kfree_skb (skb); + } +qdisc_tree_decrease_qlen (sch, qlen - sch->q.qlen); + +sch_tree_unlock (sch); +return 0 ; +} + +static int hhf_init (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +int i; + + sch->limit =1000 ; + q->quantum =psched_mtu (qdisc_dev (sch)); + q->perturbation =net_random (); +INIT_LIST_HEAD (&q->new_buckets); +INIT_LIST_HEAD (&q->old_buckets); + +/* Configurable HHF parameters */ + q->hhf_reset_timeout =HZ /25 ;/* 40 ms */ + q->hhf_admit_bytes =131072 ;/* 128 KB */ + q->hhf_evict_timeout =HZ ;/* 1 sec */ + q->hhf_non_hh_weight =2 ; + +if (opt) { +int err =hhf_change (sch, opt); + +if (err) +return err; + } + +if (!q->hh_flows) { +/* Initialize heavy-hitter flow table. */ + q->hh_flows =hhf_zalloc (HH_FLOWS_CNT * +sizeof (struct list_head )); +if (!q->hh_flows) +return -ENOMEM ; +for (i =0 ; i <HH_FLOWS_CNT ; i++) +INIT_LIST_HEAD (&q->hh_flows[i]); + +/* Cap max active HHs at twice len of hh_flows table. */ + q->hh_flows_limit =2 *HH_FLOWS_CNT ; + q->hh_flows_overlimit =0 ; + q->hh_flows_total_cnt =0 ; + q->hh_flows_current_cnt =0 ; + +/* Initialize heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_arrays[i] =hhf_zalloc (HHF_ARRAYS_LEN * +sizeof (u32)); +if (!q->hhf_arrays[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + q->hhf_arrays_reset_timestamp =hhf_time_stamp (); + +/* Initialize valid bits of heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_valid_bits[i] =hhf_zalloc (HHF_ARRAYS_LEN / +BITS_PER_BYTE ); +if (!q->hhf_valid_bits[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + +/* Initialize Weighted DRR buckets. */ +for (i =0 ; i <WDRR_BUCKET_CNT ; i++) { +struct wdrr_bucket *bucket = q->buckets + i; + +INIT_LIST_HEAD (&bucket->bucketchain); + } + } + +return 0 ; +} + +static int hhf_dump (struct Qdisc *sch,struct sk_buff *skb) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *opts; + + opts =nla_nest_start (skb,TCA_OPTIONS ); +if (opts ==NULL ) + goto nla_put_failure; + +if (nla_put_u32 (skb,TCA_HHF_BACKLOG_LIMIT , sch->limit) || +nla_put_u32 (skb,TCA_HHF_QUANTUM , q->quantum) || +nla_put_u32 (skb,TCA_HHF_HH_FLOWS_LIMIT , q->hh_flows_limit) || +nla_put_u32 (skb,TCA_HHF_RESET_TIMEOUT , +jiffies_to_msecs (q->hhf_reset_timeout)) || +nla_put_u32 (skb,TCA_HHF_ADMIT_BYTES , q->hhf_admit_bytes) || +nla_put_u32 (skb,TCA_HHF_EVICT_TIMEOUT , +jiffies_to_msecs (q->hhf_evict_timeout)) || +nla_put_u32 (skb,TCA_HHF_NON_HH_WEIGHT , q->hhf_non_hh_weight)) + goto nla_put_failure; + +nla_nest_end (skb, opts); +return skb->len; + +nla_put_failure: +return -1 ; +} + +static int hhf_dump_stats (struct Qdisc *sch,struct gnet_dump *d) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct tc_hhf_xstats st = { + .drop_overlimit = q->drop_overlimit, + .hh_overlimit = q->hh_flows_overlimit, + .hh_tot_count = q->hh_flows_total_cnt, + .hh_cur_count = q->hh_flows_current_cnt, + }; + +return gnet_stats_copy_app (d, &st,sizeof (st)); +} + +struct Qdisc_ops hhf_qdisc_ops__read_mostly = { + .id ="hhf" , + .priv_size =sizeof (struct hhf_sched_data ), + + .enqueue = hhf_enqueue, + .dequeue = hhf_dequeue, + .peek = qdisc_peek_dequeued, + .drop = hhf_drop, + .init = hhf_init, + .reset = hhf_reset, + .destroy = hhf_destroy, + .change = hhf_change, + .dump = hhf_dump, + .dump_stats = hhf_dump_stats, + .owner =THIS_MODULE , +}; +EXPORT_SYMBOL (hhf_qdisc_ops); + +static int __init hhf_module_init (void ) +{ +return register_qdisc (&hhf_qdisc_ops); +} + +static void __exit hhf_module_exit(void) +{ +unregister_qdisc (&hhf_qdisc_ops); +} + +module_init(hhf_module_init) +module_exit(hhf_module_exit) +MODULE_AUTHOR("Terry Lam"); +MODULE_AUTHOR ("Nandita Dukkipati" ); +MODULE_LICENSE ("GPL" ); --1.8.5.1
--
To unsubscribe from this list: send the line "unsubscribe netdev" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Tom,
Perturbation is mainly for added security (e.g. intentional hash collision to map an elephant to the high priority bucket). I just looked at the code and it looks like skb_get_hash (indeed, __skb_get_hash) does not have perturbation.
Do you mean we will soon perturbation for connected sockets?
Terry
Quoted 888 lines · Tom Herbert
Terry,
HHF defines it's own
skb_hashfunction. Do you see any issues if we remove this and callskb_get_hashinstead. We'll have functionality in TX to setskb->hashfromsk_hash. The only difference is that in non-connected socket case we won't includeq->perturbationin the jhash-- how important is this?Quoted 877 lines · Terry Lam
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +25
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif net/sched/Kconfig +9
-0@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACTnet/sched/Makefile +1
-0@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.onet/sched/sch_hhf.c new file +746
-1@@ -0,0 +1,746 @@ +/* net/sched/sch_hhf.c Heavy-Hitter Filter (HHF) +* +* Copyright (C) 2013 Terry Lam <[email protected]> +* Copyright (C) 2013 Nandita Dukkipati <[email protected]> +*/ + +#include <linux/jhash.h> +#include <linux/jiffies.h> +#include <linux/module.h> +#include <linux/skbuff.h> +#include <linux/vmalloc.h> +#include <net/flow_keys.h> +#include <net/pkt_sched.h> +#include <net/sock.h> + +/* Heavy-Hitter Filter (HHF) +* +* Principles : +* Flows are classified into two buckets: non-heavy-hitter and heavy-hitter +* buckets. Initially, a new flow starts as non-heavy-hitter. Once classified +* as heavy-hitter, it is immediately switched to the heavy-hitter bucket. +* The buckets are dequeued by a Weighted Deficit Round Robin (WDRR) scheduler, +* in which the heavy-hitter bucket is served with less weight. +* In other words, non-heavy-hitters (e.g., short bursts of critical traffic) +* are isolated from heavy-hitters (e.g., persistent bulk traffic) and also have +* higher share of bandwidth. +* +* To capture heavy-hitters, we use the "multi-stage filter" algorithm in the +* following paper: +* [EV02] C. Estan and G. Varghese, "New Directions in Traffic Measurement and +* Accounting", in ACM SIGCOMM, 2002. +* +* Conceptually, a multi-stage filter comprises k independent hash functions +* and k counter arrays. Packets are indexed into k counter arrays by k hash +* functions, respectively. The counters are then increased by the packet sizes. +* Therefore, +* - For a heavy-hitter flow: *all* of its k array counters must be large. +* - For a non-heavy-hitter flow: some of its k array counters can be large +* due to hash collision with other small flows; however, with high +* probability, not *all* k counters are large. +* +* By the design of the multi-stage filter algorithm, the false negative rate +* (heavy-hitters getting away uncaptured) is zero. However, the algorithm is +* susceptible to false positives (non-heavy-hitters mistakenly classified as +* heavy-hitters). +* Therefore, we also implement the following optimizations to reduce false +* positives by avoiding unnecessary increment of the counter values: +* - Optimization O1: once a heavy-hitter is identified, its bytes are not +* accounted in the array counters. This technique is called "shielding" +* in Section 3.3.1 of [EV02]. +* - Optimization O2: conservative update of counters +* (Section 3.3.2 of [EV02]), +* New counter value = max {old counter value, +* smallest counter value + packet bytes} +* +* Finally, we refresh the counters periodically since otherwise the counter +* values will keep accumulating. +* +* Once a flow is classified as heavy-hitter, we also save its per-flow state +* in an exact-matching flow table so that its subsequent packets can be +* dispatched to the heavy-hitter bucket accordingly. +* +* +* At a high level, this qdisc works as follows: +* Given a packet p: +* - If the flow-id of p (e.g., TCP 5-tuple) is already in the exact-matching +* heavy-hitter flow table, denoted table T, then send p to the heavy-hitter +* bucket. +* - Otherwise, forward p to the multi-stage filter, denoted filter F +* + If F decides that p belongs to a non-heavy-hitter flow, then send p +* to the non-heavy-hitter bucket. +* + Otherwise, if F decides that p belongs to a new heavy-hitter flow, +* then set up a new flow entry for the flow-id of p in the table T and +* send p to the heavy-hitter bucket. +* +* In this implementation: +* - T is a fixed-size hash-table with 1024 entries. Hash collision is +* resolved by linked-list chaining. +* - F has four counter arrays, each array containing 1024 32-bit counters. +* That means 4 * 1024 * 32 bits = 16KB of memory. +* - Since each array in F contains 1024 counters, 10 bits are sufficient to +* index into each array. +* Hence, instead of having four hash functions, we chop the 32-bit +* skb-hash into three 10-bit chunks, and the remaining 10-bit chunk is +* computed as XOR sum of those three chunks. +* - We need to clear the counter arrays periodically; however, directly +* memsetting 16KB of memory can lead to cache eviction and unwanted delay. +* So by representing each counter by a valid bit, we only need to reset +* 4K of 1 bit (i.e. 512 bytes) instead of 16KB of memory. +* - The Deficit Round Robin engine is taken from fq_codel implementation +* (net/sched/sch_fq_codel.c). Note that wdrr_bucket corresponds to +* fq_codel_flow in fq_codel implementation. +* +*/ + +/* Non-configurable parameters */ +#define HH_FLOWS_CNT 1024/* number of entries in exact-matching table T */ +#define HHF_ARRAYS_CNT 4/* number of arrays in multi-stage filter F */ +#define HHF_ARRAYS_LEN 1024/* number of counters in each array of F */ +#define HHF_BIT_MASK_LEN 10/* masking 10 bits */ +#define HHF_BIT_MASK 0x3FF/* bitmask of 10 bits */ + +#define WDRR_BUCKET_CNT 2/* two buckets for Weighted DRR */ +enum wdrr_bucket_idx { +WDRR_BUCKET_FOR_HH =0 ,/* bucket id for heavy-hitters */ +WDRR_BUCKET_FOR_NON_HH =1 /* bucket id for non-heavy-hitters */ +}; + +#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0)) + +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/ +u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/ +}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +} + +static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash; + +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; + +skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +} + +/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +} + +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head; + + bucket->head = skb->next; + skb->next =NULL ; +return skb; +} + +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +} + +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); + +if (!ptr) + ptr =vzalloc (sz); + +return ptr; +} + +static void hhf_free (void *addr) +{ +if (addr) { +if (is_vmalloc_addr (addr)) +vfree (addr); +else +kfree (addr); + } +} + +static void hhf_destroy (struct Qdisc *sch) +{ +int i; +struct hhf_sched_data *q =qdisc_priv (sch); + +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +hhf_free (q->hhf_arrays[i]); +hhf_free (q->hhf_valid_bits[i]); + } + +for (i =0 ; i <HH_FLOWS_CNT ; i++) { +struct hh_flow_state *flow, *next; +struct list_head *head = &q->hh_flows[i]; + +if (list_empty (head)) +continue ; +list_for_each_entry_safe (flow, next, head, flowchain) { +list_del (&flow->flowchain); +kfree (flow); + } + } +hhf_free (q->hh_flows); +} + +static const struct nla_policy hhf_policy[TCA_HHF_MAX +1 ] = { + [TCA_HHF_BACKLOG_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_QUANTUM ] = { .type =NLA_U32 }, + [TCA_HHF_HH_FLOWS_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_RESET_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_ADMIT_BYTES ] = { .type =NLA_U32 }, + [TCA_HHF_EVICT_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_NON_HH_WEIGHT ] = { .type =NLA_U32 }, +}; + +static int hhf_change (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *tb[TCA_HHF_MAX +1 ]; +unsigned int qlen; +int err; +u64 non_hh_quantum; +u32 new_quantum = q->quantum; +u32 new_hhf_non_hh_weight = q->hhf_non_hh_weight; + +if (!opt) +return -EINVAL ; + + err =nla_parse_nested (tb,TCA_HHF_MAX , opt, hhf_policy); +if (err <0 ) +return err; + +sch_tree_lock (sch); + +if (tb[TCA_HHF_BACKLOG_LIMIT ]) + sch->limit =nla_get_u32 (tb[TCA_HHF_BACKLOG_LIMIT ]); + +if (tb[TCA_HHF_QUANTUM ]) + new_quantum =nla_get_u32 (tb[TCA_HHF_QUANTUM ]); + +if (tb[TCA_HHF_NON_HH_WEIGHT ]) + new_hhf_non_hh_weight =nla_get_u32 (tb[TCA_HHF_NON_HH_WEIGHT ]); + + non_hh_quantum = (u64 )new_quantum * new_hhf_non_hh_weight; +if (non_hh_quantum >INT_MAX ) +return -EINVAL ; + q->quantum = new_quantum; + q->hhf_non_hh_weight = new_hhf_non_hh_weight; + +if (tb[TCA_HHF_HH_FLOWS_LIMIT ]) + q->hh_flows_limit =nla_get_u32 (tb[TCA_HHF_HH_FLOWS_LIMIT ]); + +if (tb[TCA_HHF_RESET_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_RESET_TIMEOUT ]); + + q->hhf_reset_timeout =msecs_to_jiffies (ms); + } + +if (tb[TCA_HHF_ADMIT_BYTES ]) + q->hhf_admit_bytes =nla_get_u32 (tb[TCA_HHF_ADMIT_BYTES ]); + +if (tb[TCA_HHF_EVICT_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_EVICT_TIMEOUT ]); + + q->hhf_evict_timeout =msecs_to_jiffies (ms); + } + + qlen = sch->q.qlen; +while (sch->q.qlen > sch->limit) { +struct sk_buff *skb =hhf_dequeue (sch); + +kfree_skb (skb); + } +qdisc_tree_decrease_qlen (sch, qlen - sch->q.qlen); + +sch_tree_unlock (sch); +return 0 ; +} + +static int hhf_init (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +int i; + + sch->limit =1000 ; + q->quantum =psched_mtu (qdisc_dev (sch)); + q->perturbation =net_random (); +INIT_LIST_HEAD (&q->new_buckets); +INIT_LIST_HEAD (&q->old_buckets); + +/* Configurable HHF parameters */ + q->hhf_reset_timeout =HZ /25 ;/* 40 ms */ + q->hhf_admit_bytes =131072 ;/* 128 KB */ + q->hhf_evict_timeout =HZ ;/* 1 sec */ + q->hhf_non_hh_weight =2 ; + +if (opt) { +int err =hhf_change (sch, opt); + +if (err) +return err; + } + +if (!q->hh_flows) { +/* Initialize heavy-hitter flow table. */ + q->hh_flows =hhf_zalloc (HH_FLOWS_CNT * +sizeof (struct list_head )); +if (!q->hh_flows) +return -ENOMEM ; +for (i =0 ; i <HH_FLOWS_CNT ; i++) +INIT_LIST_HEAD (&q->hh_flows[i]); + +/* Cap max active HHs at twice len of hh_flows table. */ + q->hh_flows_limit =2 *HH_FLOWS_CNT ; + q->hh_flows_overlimit =0 ; + q->hh_flows_total_cnt =0 ; + q->hh_flows_current_cnt =0 ; + +/* Initialize heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_arrays[i] =hhf_zalloc (HHF_ARRAYS_LEN * +sizeof (u32)); +if (!q->hhf_arrays[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + q->hhf_arrays_reset_timestamp =hhf_time_stamp (); + +/* Initialize valid bits of heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_valid_bits[i] =hhf_zalloc (HHF_ARRAYS_LEN / +BITS_PER_BYTE ); +if (!q->hhf_valid_bits[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + +/* Initialize Weighted DRR buckets. */ +for (i =0 ; i <WDRR_BUCKET_CNT ; i++) { +struct wdrr_bucket *bucket = q->buckets + i; + +INIT_LIST_HEAD (&bucket->bucketchain); + } + } + +return 0 ; +} + +static int hhf_dump (struct Qdisc *sch,struct sk_buff *skb) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *opts; + + opts =nla_nest_start (skb,TCA_OPTIONS ); +if (opts ==NULL ) + goto nla_put_failure; + +if (nla_put_u32 (skb,TCA_HHF_BACKLOG_LIMIT , sch->limit) || +nla_put_u32 (skb,TCA_HHF_QUANTUM , q->quantum) || +nla_put_u32 (skb,TCA_HHF_HH_FLOWS_LIMIT , q->hh_flows_limit) || +nla_put_u32 (skb,TCA_HHF_RESET_TIMEOUT , +jiffies_to_msecs (q->hhf_reset_timeout)) || +nla_put_u32 (skb,TCA_HHF_ADMIT_BYTES , q->hhf_admit_bytes) || +nla_put_u32 (skb,TCA_HHF_EVICT_TIMEOUT , +jiffies_to_msecs (q->hhf_evict_timeout)) || +nla_put_u32 (skb,TCA_HHF_NON_HH_WEIGHT , q->hhf_non_hh_weight)) + goto nla_put_failure; + +nla_nest_end (skb, opts); +return skb->len; + +nla_put_failure: +return -1 ; +} + +static int hhf_dump_stats (struct Qdisc *sch,struct gnet_dump *d) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct tc_hhf_xstats st = { + .drop_overlimit = q->drop_overlimit, + .hh_overlimit = q->hh_flows_overlimit, + .hh_tot_count = q->hh_flows_total_cnt, + .hh_cur_count = q->hh_flows_current_cnt, + }; + +return gnet_stats_copy_app (d, &st,sizeof (st)); +} + +struct Qdisc_ops hhf_qdisc_ops__read_mostly = { + .id ="hhf" , + .priv_size =sizeof (struct hhf_sched_data ), + + .enqueue = hhf_enqueue, + .dequeue = hhf_dequeue, + .peek = qdisc_peek_dequeued, + .drop = hhf_drop, + .init = hhf_init, + .reset = hhf_reset, + .destroy = hhf_destroy, + .change = hhf_change, + .dump = hhf_dump, + .dump_stats = hhf_dump_stats, + .owner =THIS_MODULE , +}; +EXPORT_SYMBOL (hhf_qdisc_ops); + +static int __init hhf_module_init (void ) +{ +return register_qdisc (&hhf_qdisc_ops); +} + +static void __exit hhf_module_exit(void) +{ +unregister_qdisc (&hhf_qdisc_ops); +} + +module_init(hhf_module_init) +module_exit(hhf_module_exit) +MODULE_AUTHOR("Terry Lam"); +MODULE_AUTHOR ("Nandita Dukkipati" ); +MODULE_LICENSE ("GPL" ); --1.8.5.1
--
To unsubscribe from this list: send the line "unsubscribe netdev" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Quoted 8 lines · Terry Lam
Hi Tom,
Perturbation is mainly for added security (e.g. intentional hash collision to map an elephant to the high priority bucket). I just looked at the code and it looks like
skb_get_hash(indeed,__skb_get_hash) does not have perturbation.
Do you mean we will soon perturbation for connected sockets?
That is an interesting question. We are already using skb->hash in several cases without any perturbation. I think there are two possibilities:
1) Add some sort of global perturbation to skb_get_hash
2) Add function skb_get_hash_perturb(skb, perturbation)
I think there may be merit to second, it might resolve one concern I have is that using the same hash value for multiple purposes may reduce entropy e.g.
if (hash & 1) .... if (hash &1)-- second condition always hits since first did same filter.
Quoted 892 lines
Terry
Quoted 888 lines · Tom Herbert
Terry,
HHF defines it's own
skb_hashfunction. Do you see any issues if we remove this and callskb_get_hashinstead. We'll have functionality in TX to setskb->hashfromsk_hash. The only difference is that in non-connected socket case we won't includeq->perturbationin the jhash-- how important is this?Quoted 877 lines · Terry Lam
This patch implements the first size-based qdisc that attempts to differentiate between small flows and heavy-hitters. The goal is to catch the heavy-hitters and move them to a separate queue with less priority so that bulk traffic does not affect the latency of critical traffic. Currently "less priority" means less weight (2:1 in particular) in a Weighted Deficit Round Robin (WDRR) scheduler.
In essence, this patch addresses the "delay-bloat" problem due to bloated buffers. In some systems, large queues may be necessary for obtaining CPU efficiency, or due to the presence of unresponsive traffic like UDP, or just a large number of connections with each having a small amount of outstanding traffic. In these circumstances, HHF aims to reduce the HoL blocking for latency sensitive traffic, while not impacting the queues built up by bulk traffic. HHF can also be used in conjunction with other AQM mechanisms such as CoDel.
To capture heavy-hitters, we implement the "multi-stage filter" design in the following paper:
C. Estan and G. Varghese, "New Directions in Traffic Measurement and Accounting", in ACM SIGCOMM, 2002.Some configurable qdisc settings through 'tc':
-hhf_reset_timeout: period to reset counter values in the multi-stage filter (default 40ms)
-hhf_admit_bytes: threshold to classify heavy-hitters(default 128KB)-
hhf_evict_timeout: threshold to evict idle heavy-hitters (default 1s)
-hhf_non_hh_weight: Weighted Deficit Round Robin (WDRR) weight for non-heavy-hitters (default 2)
-hh_flows_limit: max number of heavy-hitter flow entries(default 2048)Note that the ratio between
hhf_admit_bytesandhhf_reset_timeoutreflects the bandwidth of heavy-hitters that we attempt to capture (25Mbps with the above default settings).The false negative rate (heavy-hitter flows getting away unclassified) is zero by the design of the multi-stage filter algorithm. With 100 heavy-hitter flows, using four hashes and 4000 counters yields a false positive rate (non-heavy-hitters mistakenly classified as heavy-hitters) of less than 1e-4.
Signed-off-by Terry Lam <[email protected]>--- include/uapi/linux/pkt_sched.h | 25 ++ net/sched/Kconfig | 9 + net/sched/Makefile | 1 + net/sched/sch_hhf.c | 746 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 781 insertions(+) create mode 100644 net/sched/sch_hhf.cinclude/uapi/linux/pkt_sched.h +25
-0@@ -790,4 +790,29 @@ struct tc_fq_qd_stats {__u32 throttled_flows; __u32 pad; }; + +/* Heavy-Hitter Filter */ + +enum { +TCA_HHF_UNSPEC , +TCA_HHF_BACKLOG_LIMIT , +TCA_HHF_QUANTUM , +TCA_HHF_HH_FLOWS_LIMIT , +TCA_HHF_RESET_TIMEOUT , +TCA_HHF_ADMIT_BYTES , +TCA_HHF_EVICT_TIMEOUT , +TCA_HHF_NON_HH_WEIGHT , + __TCA_HHF_MAX +}; + +#define TCA_HHF_MAX (__TCA_HHF_MAX - 1) + +struct tc_hhf_xstats { +__u32 drop_overlimit;/* number of times max qdisc packet limit +* was hit +*/ +__u32 hh_overlimit;/* number of times max heavy-hitters was hit */ +__u32 hh_tot_count;/* number of captured heavy-hitters so far */ +__u32 hh_cur_count;/* number of current heavy-hitters */ +};#endif net/sched/Kconfig +9
-0@@ -286,6 +286,15 @@ config NET_SCH_FQ If unsure, say N. +config NET_SCH_HHF + tristate "Heavy-Hitter Filter (HHF)" + help + Say Y here if you want to use the Heavy-Hitter Filter (HHF) + packet scheduling algorithm. + + To compile this driver as a module, choose M here: the module + will be called sch_hhf. + config NET_SCH_INGRESS tristate "Ingress Qdisc" depends on NET_CLS_ACTnet/sched/Makefile +1
-0@@ -40,6 +40,7 @@ obj-$(CONFIG_NET_SCH_QFQ) += sch_qfq.o obj-$(CONFIG_NET_SCH_CODEL) += sch_codel.o obj-$(CONFIG_NET_SCH_FQ_CODEL) += sch_fq_codel.o obj-$(CONFIG_NET_SCH_FQ) += sch_fq.o +obj-$(CONFIG_NET_SCH_HHF) += sch_hhf.o obj-$(CONFIG_NET_CLS_U32) += cls_u32.o obj-$(CONFIG_NET_CLS_ROUTE4) += cls_route.onet/sched/sch_hhf.c new file +746
-1@@ -0,0 +1,746 @@ +/* net/sched/sch_hhf.c Heavy-Hitter Filter (HHF) +* +* Copyright (C) 2013 Terry Lam <[email protected]> +* Copyright (C) 2013 Nandita Dukkipati <[email protected]> +*/ + +#include <linux/jhash.h> +#include <linux/jiffies.h> +#include <linux/module.h> +#include <linux/skbuff.h> +#include <linux/vmalloc.h> +#include <net/flow_keys.h> +#include <net/pkt_sched.h> +#include <net/sock.h> + +/* Heavy-Hitter Filter (HHF) +* +* Principles : +* Flows are classified into two buckets: non-heavy-hitter and heavy-hitter +* buckets. Initially, a new flow starts as non-heavy-hitter. Once classified +* as heavy-hitter, it is immediately switched to the heavy-hitter bucket. +* The buckets are dequeued by a Weighted Deficit Round Robin (WDRR) scheduler, +* in which the heavy-hitter bucket is served with less weight. +* In other words, non-heavy-hitters (e.g., short bursts of critical traffic) +* are isolated from heavy-hitters (e.g., persistent bulk traffic) and also have +* higher share of bandwidth. +* +* To capture heavy-hitters, we use the "multi-stage filter" algorithm in the +* following paper: +* [EV02] C. Estan and G. Varghese, "New Directions in Traffic Measurement and +* Accounting", in ACM SIGCOMM, 2002. +* +* Conceptually, a multi-stage filter comprises k independent hash functions +* and k counter arrays. Packets are indexed into k counter arrays by k hash +* functions, respectively. The counters are then increased by the packet sizes. +* Therefore, +* - For a heavy-hitter flow: *all* of its k array counters must be large. +* - For a non-heavy-hitter flow: some of its k array counters can be large +* due to hash collision with other small flows; however, with high +* probability, not *all* k counters are large. +* +* By the design of the multi-stage filter algorithm, the false negative rate +* (heavy-hitters getting away uncaptured) is zero. However, the algorithm is +* susceptible to false positives (non-heavy-hitters mistakenly classified as +* heavy-hitters). +* Therefore, we also implement the following optimizations to reduce false +* positives by avoiding unnecessary increment of the counter values: +* - Optimization O1: once a heavy-hitter is identified, its bytes are not +* accounted in the array counters. This technique is called "shielding" +* in Section 3.3.1 of [EV02]. +* - Optimization O2: conservative update of counters +* (Section 3.3.2 of [EV02]), +* New counter value = max {old counter value, +* smallest counter value + packet bytes} +* +* Finally, we refresh the counters periodically since otherwise the counter +* values will keep accumulating. +* +* Once a flow is classified as heavy-hitter, we also save its per-flow state +* in an exact-matching flow table so that its subsequent packets can be +* dispatched to the heavy-hitter bucket accordingly. +* +* +* At a high level, this qdisc works as follows: +* Given a packet p: +* - If the flow-id of p (e.g., TCP 5-tuple) is already in the exact-matching +* heavy-hitter flow table, denoted table T, then send p to the heavy-hitter +* bucket. +* - Otherwise, forward p to the multi-stage filter, denoted filter F +* + If F decides that p belongs to a non-heavy-hitter flow, then send p +* to the non-heavy-hitter bucket. +* + Otherwise, if F decides that p belongs to a new heavy-hitter flow, +* then set up a new flow entry for the flow-id of p in the table T and +* send p to the heavy-hitter bucket. +* +* In this implementation: +* - T is a fixed-size hash-table with 1024 entries. Hash collision is +* resolved by linked-list chaining. +* - F has four counter arrays, each array containing 1024 32-bit counters. +* That means 4 * 1024 * 32 bits = 16KB of memory. +* - Since each array in F contains 1024 counters, 10 bits are sufficient to +* index into each array. +* Hence, instead of having four hash functions, we chop the 32-bit +* skb-hash into three 10-bit chunks, and the remaining 10-bit chunk is +* computed as XOR sum of those three chunks. +* - We need to clear the counter arrays periodically; however, directly +* memsetting 16KB of memory can lead to cache eviction and unwanted delay. +* So by representing each counter by a valid bit, we only need to reset +* 4K of 1 bit (i.e. 512 bytes) instead of 16KB of memory. +* - The Deficit Round Robin engine is taken from fq_codel implementation +* (net/sched/sch_fq_codel.c). Note that wdrr_bucket corresponds to +* fq_codel_flow in fq_codel implementation. +* +*/ + +/* Non-configurable parameters */ +#define HH_FLOWS_CNT 1024/* number of entries in exact-matching table T */ +#define HHF_ARRAYS_CNT 4/* number of arrays in multi-stage filter F */ +#define HHF_ARRAYS_LEN 1024/* number of counters in each array of F */ +#define HHF_BIT_MASK_LEN 10/* masking 10 bits */ +#define HHF_BIT_MASK 0x3FF/* bitmask of 10 bits */ + +#define WDRR_BUCKET_CNT 2/* two buckets for Weighted DRR */ +enum wdrr_bucket_idx { +WDRR_BUCKET_FOR_HH =0 ,/* bucket id for heavy-hitters */ +WDRR_BUCKET_FOR_NON_HH =1 /* bucket id for non-heavy-hitters */ +}; + +#define hhf_time_before (a, b) \ + (typecheck(u32, a) && typecheck(u32, b) && ((s32)((a) - (b)) < 0)) + +/* Heavy-hitter per-flow state */ +struct hh_flow_state { +u32 hash_id;/* hash of flow-id (e.g. TCP 5-tuple) */ +u32 hit_timestamp;/* last time heavy-hitter was seen */ +struct list_head flowchain;/* chaining under hash collision */ +}; + +/* Weighted Deficit Round Robin (WDRR) scheduler */ +struct wdrr_bucket { +struct sk_buff *head; +struct sk_buff *tail; +struct list_head bucketchain; +int deficit; +}; + +struct hhf_sched_data { +struct wdrr_bucket buckets[WDRR_BUCKET_CNT ]; +u32 perturbation;/* hash perturbation */ +u32 quantum;/* psched_mtu(qdisc_dev(sch)); */ +u32 drop_overlimit;/* number of times max qdisc packet +* limit was hit +*/ +struct list_head *hh_flows;/* table T (currently active HHs) */ +u32 hh_flows_limit;/* max active HH allocs */ +u32 hh_flows_overlimit;/* num of disallowed HH allocs */ +u32 hh_flows_total_cnt;/* total admitted HHs */ +u32 hh_flows_current_cnt;/* total current HHs */ +u32 *hhf_arrays[HHF_ARRAYS_CNT ];/* HH filter F */ +u32 hhf_arrays_reset_timestamp;/* last time hhf_arrays +* was reset +*/ +unsigned long *hhf_valid_bits[HHF_ARRAYS_CNT ];/* shadow valid bits +* of hhf_arrays +*/ +/* Similar to the "new_flows" vs. "old_flows" concept in fq_codel DRR */ +struct list_head new_buckets;/* list of new buckets */ +struct list_head old_buckets;/* list of old buckets */ + +/* Configurable HHF parameters */ +u32 hhf_reset_timeout;/* interval to reset counter +* arrays in filter F +* (default 40ms) +*/ +u32 hhf_admit_bytes;/* counter thresh to classify as +* HH (default 128KB). +* With these default values, +* 128KB / 40ms = 25 Mbps +* i.e., we expect to capture HHs +* sending > 25 Mbps. +*/ +u32 hhf_evict_timeout;/* aging threshold to evict idle +* HHs out of table T. This should +* be large enough to avoid +* reordering during HH eviction. +* (default 1s) +*/ +u32 hhf_non_hh_weight;/* WDRR weight for non-HHs +* (default 2, +* i.e., non-HH : HH = 2 : 1) +*/ +}; + +static inline u32 hhf_time_stamp (void ) +{ +return jiffies; +} + +static unsigned int skb_hash (const struct hhf_sched_data *q, +const struct sk_buff *skb) +{ +struct flow_keys keys; +unsigned int hash; + +if (skb->sk && skb->sk->sk_hash) +return skb->sk->sk_hash; + +skb_flow_dissect (skb, &keys); + hash =jhash_3words ((__force u32 )keys.dst, + (__force u32 )keys.src ^ keys.ip_proto, + (__force u32 )keys.ports, q->perturbation); +return hash; +} + +/* Looks up a heavy-hitter flow in a chaining list of table T. */ +static inline struct hh_flow_state *seek_list (const u32 hash, +struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow, *next; +u32 now =hhf_time_stamp (); + +if (list_empty (head)) +return NULL ; + +list_for_each_entry_safe (flow, next, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) { +/* Delete expired heavy-hitters, but preserve one entry +* to avoid kzalloc() when next time this slot is hit. +*/ +if (list_is_last (&flow->flowchain, head)) +return NULL ; +list_del (&flow->flowchain); +kfree (flow); + q->hh_flows_current_cnt--; + }else if (flow->hash_id == hash) { +return flow; + } + } +return NULL ; +} + +/* Returns a flow state entry for a new heavy-hitter. Either reuses an expired +* entry or dynamically alloc a new entry. +*/ +static inline struct hh_flow_state *alloc_new_hh (struct list_head *head, +struct hhf_sched_data *q) +{ +struct hh_flow_state *flow; +u32 now =hhf_time_stamp (); + +if (!list_empty (head)) { +/* Find an expired heavy-hitter flow entry. */ +list_for_each_entry (flow, head, flowchain) { +u32 prev = flow->hit_timestamp + q->hhf_evict_timeout; + +if (hhf_time_before (prev, now)) +return flow; + } + } + +if (q->hh_flows_current_cnt >= q->hh_flows_limit) { + q->hh_flows_overlimit++; +return NULL ; + } +/* Create new entry. */ + flow =kzalloc (sizeof (struct hh_flow_state ),GFP_ATOMIC ); +if (!flow) +return NULL ; + + q->hh_flows_current_cnt++; +INIT_LIST_HEAD (&flow->flowchain); +list_add_tail (&flow->flowchain, head); + +return flow; +} + +/* Assigns packets to WDRR buckets. Implements a multi-stage filter to +* classify heavy-hitters. +*/ +static enum wdrr_bucket_idx hhf_classify (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +u32 tmp_hash, hash; +u32 xorsum, filter_pos[HHF_ARRAYS_CNT ], flow_pos; +struct hh_flow_state *flow; +u32 pkt_len, min_hhf_val; +int i; +u32 prev; +u32 now =hhf_time_stamp (); + +/* Reset the HHF counter arrays if this is the right time. */ + prev = q->hhf_arrays_reset_timestamp + q->hhf_reset_timeout; +if (hhf_time_before (prev, now)) { +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) +bitmap_zero (q->hhf_valid_bits[i],HHF_ARRAYS_LEN ); + q->hhf_arrays_reset_timestamp = now; + } + +/* Get hashed flow-id of the skb. */ + hash =skb_hash (q, skb); + +/* Check if this packet belongs to an already established HH flow. */ + flow_pos = hash &HHF_BIT_MASK ; + flow =seek_list (hash, &q->hh_flows[flow_pos], q); +if (flow) {/* found its HH flow */ + flow->hit_timestamp = now; +return WDRR_BUCKET_FOR_HH ; + } + +/* Now pass the packet through the multi-stage filter. */ + tmp_hash = hash; + xorsum =0 ; +for (i =0 ; i <HHF_ARRAYS_CNT -1 ; i++) { +/* Split the skb_hash into three 10-bit chunks. */ + filter_pos[i] = tmp_hash &HHF_BIT_MASK ; + xorsum ^= filter_pos[i]; + tmp_hash >>=HHF_BIT_MASK_LEN ; + } +/* The last chunk is computed as XOR sum of other chunks. */ + filter_pos[HHF_ARRAYS_CNT -1 ] = xorsum ^ tmp_hash; + + pkt_len =qdisc_pkt_len (skb); + min_hhf_val = ~0U ; +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +u32 val; + +if (!test_bit (filter_pos[i], q->hhf_valid_bits[i])) { + q->hhf_arrays[i][filter_pos[i]] =0 ; +__set_bit (filter_pos[i], q->hhf_valid_bits[i]); + } + + val = q->hhf_arrays[i][filter_pos[i]] + pkt_len; +if (min_hhf_val > val) + min_hhf_val = val; + } + +/* Found a new HH iff all counter values > HH admit threshold. */ +if (min_hhf_val > q->hhf_admit_bytes) { +/* Just captured a new heavy-hitter. */ + flow =alloc_new_hh (&q->hh_flows[flow_pos], q); +if (!flow)/* memory alloc problem */ +return WDRR_BUCKET_FOR_NON_HH ; + flow->hash_id = hash; + flow->hit_timestamp = now; + q->hh_flows_total_cnt++; + +/* By returning without updating counters in q->hhf_arrays, +* we implicitly implement "shielding" (see Optimization O1). +*/ +return WDRR_BUCKET_FOR_HH ; + } + +/* Conservative update of HHF arrays (see Optimization O2). */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +if (q->hhf_arrays[i][filter_pos[i]] < min_hhf_val) + q->hhf_arrays[i][filter_pos[i]] = min_hhf_val; + } +return WDRR_BUCKET_FOR_NON_HH ; +} + +/* Removes one skb from head of bucket. */ +static inline struct sk_buff *dequeue_head (struct wdrr_bucket *bucket) +{ +struct sk_buff *skb = bucket->head; + + bucket->head = skb->next; + skb->next =NULL ; +return skb; +} + +/* Tail-adds skb to bucket. */ +static inline void bucket_add (struct wdrr_bucket *bucket,struct sk_buff *skb) +{ +if (bucket->head ==NULL ) + bucket->head = skb; +else + bucket->tail->next = skb; + bucket->tail = skb; + skb->next =NULL ; +} + +static unsigned int hhf_drop (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct wdrr_bucket *bucket; + +/* Always try to drop from heavy-hitters first. */ + bucket = &q->buckets[WDRR_BUCKET_FOR_HH ]; +if (!bucket->head) + bucket = &q->buckets[WDRR_BUCKET_FOR_NON_HH ]; + +if (bucket->head) { +struct sk_buff *skb =dequeue_head (bucket); + + sch->q.qlen--; + sch->qstats.drops++; + sch->qstats.backlog -=qdisc_pkt_len (skb); +kfree_skb (skb); + } + +/* Return id of the bucket from which the packet was dropped. */ +return bucket - q->buckets; +} + +static int hhf_enqueue (struct sk_buff *skb,struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +enum wdrr_bucket_idx idx; +struct wdrr_bucket *bucket; + + idx =hhf_classify (skb, sch); + + bucket = &q->buckets[idx]; +bucket_add (bucket, skb); + sch->qstats.backlog +=qdisc_pkt_len (skb); + +if (list_empty (&bucket->bucketchain)) { +unsigned int weight; + +/* The logic of new_buckets vs. old_buckets is the same as +* new_flows vs. old_flows in the implementation of fq_codel, +* i.e., short bursts of non-HHs should have strict priority. +*/ +if (idx ==WDRR_BUCKET_FOR_HH ) { +/* Always move heavy-hitters to old bucket. */ + weight =1 ; +list_add_tail (&bucket->bucketchain, &q->old_buckets); + }else { + weight = q->hhf_non_hh_weight; +list_add_tail (&bucket->bucketchain, &q->new_buckets); + } + bucket->deficit = weight * q->quantum; + } +if (++sch->q.qlen < sch->limit) +return NET_XMIT_SUCCESS ; + + q->drop_overlimit++; +/* Return Congestion Notification only if we dropped a packet from this +* bucket. +*/ +if (hhf_drop (sch) == idx) +return NET_XMIT_CN ; + +/* As we dropped a packet, better let upper stack know this. */ +qdisc_tree_decrease_qlen (sch,1 ); +return NET_XMIT_SUCCESS ; +} + +static struct sk_buff *hhf_dequeue (struct Qdisc *sch) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct sk_buff *skb =NULL ; +struct wdrr_bucket *bucket; +struct list_head *head; + +begin: + head = &q->new_buckets; +if (list_empty (head)) { + head = &q->old_buckets; +if (list_empty (head)) +return NULL ; + } + bucket = list_first_entry(head, struct wdrr_bucket, bucketchain); + +if (bucket->deficit <=0 ) { +int weight = (bucket - q->buckets ==WDRR_BUCKET_FOR_HH ) ? +1 : q->hhf_non_hh_weight; + + bucket->deficit += weight * q->quantum; +list_move_tail (&bucket->bucketchain, &q->old_buckets); + goto begin; + } + +if (bucket->head) { + skb =dequeue_head (bucket); + sch->q.qlen--; + sch->qstats.backlog -=qdisc_pkt_len (skb); + } + +if (!skb) { +/* Force a pass through old_buckets to prevent starvation. */ +if ((head == &q->new_buckets) && !list_empty (&q->old_buckets)) +list_move_tail (&bucket->bucketchain, &q->old_buckets); +else +list_del_init (&bucket->bucketchain); + goto begin; + } +qdisc_bstats_update (sch, skb); + bucket->deficit -=qdisc_pkt_len (skb); + +return skb; +} + +static void hhf_reset (struct Qdisc *sch) +{ +struct sk_buff *skb; + +while ((skb =hhf_dequeue (sch)) !=NULL ) +kfree_skb (skb); +} + +static void *hhf_zalloc (size_t sz) +{ +void *ptr =kzalloc (sz,GFP_KERNEL | __GFP_NOWARN); + +if (!ptr) + ptr =vzalloc (sz); + +return ptr; +} + +static void hhf_free (void *addr) +{ +if (addr) { +if (is_vmalloc_addr (addr)) +vfree (addr); +else +kfree (addr); + } +} + +static void hhf_destroy (struct Qdisc *sch) +{ +int i; +struct hhf_sched_data *q =qdisc_priv (sch); + +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { +hhf_free (q->hhf_arrays[i]); +hhf_free (q->hhf_valid_bits[i]); + } + +for (i =0 ; i <HH_FLOWS_CNT ; i++) { +struct hh_flow_state *flow, *next; +struct list_head *head = &q->hh_flows[i]; + +if (list_empty (head)) +continue ; +list_for_each_entry_safe (flow, next, head, flowchain) { +list_del (&flow->flowchain); +kfree (flow); + } + } +hhf_free (q->hh_flows); +} + +static const struct nla_policy hhf_policy[TCA_HHF_MAX +1 ] = { + [TCA_HHF_BACKLOG_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_QUANTUM ] = { .type =NLA_U32 }, + [TCA_HHF_HH_FLOWS_LIMIT ] = { .type =NLA_U32 }, + [TCA_HHF_RESET_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_ADMIT_BYTES ] = { .type =NLA_U32 }, + [TCA_HHF_EVICT_TIMEOUT ] = { .type =NLA_U32 }, + [TCA_HHF_NON_HH_WEIGHT ] = { .type =NLA_U32 }, +}; + +static int hhf_change (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *tb[TCA_HHF_MAX +1 ]; +unsigned int qlen; +int err; +u64 non_hh_quantum; +u32 new_quantum = q->quantum; +u32 new_hhf_non_hh_weight = q->hhf_non_hh_weight; + +if (!opt) +return -EINVAL ; + + err =nla_parse_nested (tb,TCA_HHF_MAX , opt, hhf_policy); +if (err <0 ) +return err; + +sch_tree_lock (sch); + +if (tb[TCA_HHF_BACKLOG_LIMIT ]) + sch->limit =nla_get_u32 (tb[TCA_HHF_BACKLOG_LIMIT ]); + +if (tb[TCA_HHF_QUANTUM ]) + new_quantum =nla_get_u32 (tb[TCA_HHF_QUANTUM ]); + +if (tb[TCA_HHF_NON_HH_WEIGHT ]) + new_hhf_non_hh_weight =nla_get_u32 (tb[TCA_HHF_NON_HH_WEIGHT ]); + + non_hh_quantum = (u64 )new_quantum * new_hhf_non_hh_weight; +if (non_hh_quantum >INT_MAX ) +return -EINVAL ; + q->quantum = new_quantum; + q->hhf_non_hh_weight = new_hhf_non_hh_weight; + +if (tb[TCA_HHF_HH_FLOWS_LIMIT ]) + q->hh_flows_limit =nla_get_u32 (tb[TCA_HHF_HH_FLOWS_LIMIT ]); + +if (tb[TCA_HHF_RESET_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_RESET_TIMEOUT ]); + + q->hhf_reset_timeout =msecs_to_jiffies (ms); + } + +if (tb[TCA_HHF_ADMIT_BYTES ]) + q->hhf_admit_bytes =nla_get_u32 (tb[TCA_HHF_ADMIT_BYTES ]); + +if (tb[TCA_HHF_EVICT_TIMEOUT ]) { +u32 ms =nla_get_u32 (tb[TCA_HHF_EVICT_TIMEOUT ]); + + q->hhf_evict_timeout =msecs_to_jiffies (ms); + } + + qlen = sch->q.qlen; +while (sch->q.qlen > sch->limit) { +struct sk_buff *skb =hhf_dequeue (sch); + +kfree_skb (skb); + } +qdisc_tree_decrease_qlen (sch, qlen - sch->q.qlen); + +sch_tree_unlock (sch); +return 0 ; +} + +static int hhf_init (struct Qdisc *sch,struct nlattr *opt) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +int i; + + sch->limit =1000 ; + q->quantum =psched_mtu (qdisc_dev (sch)); + q->perturbation =net_random (); +INIT_LIST_HEAD (&q->new_buckets); +INIT_LIST_HEAD (&q->old_buckets); + +/* Configurable HHF parameters */ + q->hhf_reset_timeout =HZ /25 ;/* 40 ms */ + q->hhf_admit_bytes =131072 ;/* 128 KB */ + q->hhf_evict_timeout =HZ ;/* 1 sec */ + q->hhf_non_hh_weight =2 ; + +if (opt) { +int err =hhf_change (sch, opt); + +if (err) +return err; + } + +if (!q->hh_flows) { +/* Initialize heavy-hitter flow table. */ + q->hh_flows =hhf_zalloc (HH_FLOWS_CNT * +sizeof (struct list_head )); +if (!q->hh_flows) +return -ENOMEM ; +for (i =0 ; i <HH_FLOWS_CNT ; i++) +INIT_LIST_HEAD (&q->hh_flows[i]); + +/* Cap max active HHs at twice len of hh_flows table. */ + q->hh_flows_limit =2 *HH_FLOWS_CNT ; + q->hh_flows_overlimit =0 ; + q->hh_flows_total_cnt =0 ; + q->hh_flows_current_cnt =0 ; + +/* Initialize heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_arrays[i] =hhf_zalloc (HHF_ARRAYS_LEN * +sizeof (u32)); +if (!q->hhf_arrays[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + q->hhf_arrays_reset_timestamp =hhf_time_stamp (); + +/* Initialize valid bits of heavy-hitter filter arrays. */ +for (i =0 ; i <HHF_ARRAYS_CNT ; i++) { + q->hhf_valid_bits[i] =hhf_zalloc (HHF_ARRAYS_LEN / +BITS_PER_BYTE ); +if (!q->hhf_valid_bits[i]) { +hhf_destroy (sch); +return -ENOMEM ; + } + } + +/* Initialize Weighted DRR buckets. */ +for (i =0 ; i <WDRR_BUCKET_CNT ; i++) { +struct wdrr_bucket *bucket = q->buckets + i; + +INIT_LIST_HEAD (&bucket->bucketchain); + } + } + +return 0 ; +} + +static int hhf_dump (struct Qdisc *sch,struct sk_buff *skb) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct nlattr *opts; + + opts =nla_nest_start (skb,TCA_OPTIONS ); +if (opts ==NULL ) + goto nla_put_failure; + +if (nla_put_u32 (skb,TCA_HHF_BACKLOG_LIMIT , sch->limit) || +nla_put_u32 (skb,TCA_HHF_QUANTUM , q->quantum) || +nla_put_u32 (skb,TCA_HHF_HH_FLOWS_LIMIT , q->hh_flows_limit) || +nla_put_u32 (skb,TCA_HHF_RESET_TIMEOUT , +jiffies_to_msecs (q->hhf_reset_timeout)) || +nla_put_u32 (skb,TCA_HHF_ADMIT_BYTES , q->hhf_admit_bytes) || +nla_put_u32 (skb,TCA_HHF_EVICT_TIMEOUT , +jiffies_to_msecs (q->hhf_evict_timeout)) || +nla_put_u32 (skb,TCA_HHF_NON_HH_WEIGHT , q->hhf_non_hh_weight)) + goto nla_put_failure; + +nla_nest_end (skb, opts); +return skb->len; + +nla_put_failure: +return -1 ; +} + +static int hhf_dump_stats (struct Qdisc *sch,struct gnet_dump *d) +{ +struct hhf_sched_data *q =qdisc_priv (sch); +struct tc_hhf_xstats st = { + .drop_overlimit = q->drop_overlimit, + .hh_overlimit = q->hh_flows_overlimit, + .hh_tot_count = q->hh_flows_total_cnt, + .hh_cur_count = q->hh_flows_current_cnt, + }; + +return gnet_stats_copy_app (d, &st,sizeof (st)); +} + +struct Qdisc_ops hhf_qdisc_ops__read_mostly = { + .id ="hhf" , + .priv_size =sizeof (struct hhf_sched_data ), + + .enqueue = hhf_enqueue, + .dequeue = hhf_dequeue, + .peek = qdisc_peek_dequeued, + .drop = hhf_drop, + .init = hhf_init, + .reset = hhf_reset, + .destroy = hhf_destroy, + .change = hhf_change, + .dump = hhf_dump, + .dump_stats = hhf_dump_stats, + .owner =THIS_MODULE , +}; +EXPORT_SYMBOL (hhf_qdisc_ops); + +static int __init hhf_module_init (void ) +{ +return register_qdisc (&hhf_qdisc_ops); +} + +static void __exit hhf_module_exit(void) +{ +unregister_qdisc (&hhf_qdisc_ops); +} + +module_init(hhf_module_init) +module_exit(hhf_module_exit) +MODULE_AUTHOR("Terry Lam"); +MODULE_AUTHOR ("Nandita Dukkipati" ); +MODULE_LICENSE ("GPL" ); --1.8.5.1
--
To unsubscribe from this list: send the line "unsubscribe netdev" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html