ipvs: unify the formula to estimate the overhead of processing connections
Subsystems (5)
PATCH v2 1/1 ipvs: unify the formula to estimate the overhead of processing connections
lc and wlc use the same formula, but lblc and lblcr use another one. There is no reason for using two different formulas for the lc variants.
The formula used by lc is used by all the lc variants in this patch.
Signed-off-by Changli Gao <[email protected]>
---
v2: use ip_vs_dest_conn_overhead() instead.
include/net/ip_vs.h | 14 ++++++++++++++ net/netfilter/ipvs/ip_vs_lblc.c | 13 +++---------- net/netfilter/ipvs/ip_vs_lblcr.c | 25 +++++++------------------ net/netfilter/ipvs/ip_vs_lc.c | 18 +----------------- net/netfilter/ipvs/ip_vs_wlc.c | 20 ++------------------ 5 files changed, 27 insertions(+), 63 deletions(-)
include/net/ip_vs.h +14 -0
@@ -1241,6 +1241,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)/* CONFIG_IP_VS_NFCT */ #endif +static inline unsigned int +ip_vs_dest_conn_overhead (struct ip_vs_dest *dest) +{ +/* +* We think the overhead of processing active connections is 256 +* times higher than that of inactive connections in average. (This +* 256 times might not be accurate, we will change it later) We +* use the following formula to estimate the overhead now: +* dest->activeconns*256 + dest->inactconns +*/ +return (atomic_read (&dest->activeconns) <<8 ) + +atomic_read (&dest->inactconns); +} +#endif /* __KERNEL__ */ #endif /* _NET_IP_VS_H */
net/netfilter/ipvs/ip_vs_lblc.c +3 -10
@@ -389,12 +389,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)int loh, doh;/* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!!
@@ -410,8 +405,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)continue ;if (atomic_read (&dest->weight) >0 ) { least = dest; - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }
@@ -425,8 +419,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if (loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) { least = dest;
net/netfilter/ipvs/ip_vs_lblcr.c +7 -18
@@ -178,8 +178,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set)if ((atomic_read (&least->weight) >0 ) && (least->flags &IP_VS_DEST_F_AVAILABLE )) { - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }
@@ -192,8 +191,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if ((loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) && (dest->flags &IP_VS_DEST_F_AVAILABLE )) {
@@ -228,8 +226,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)list_for_each_entry (e, &set->list, list) { most = e->dest;if (atomic_read (&most->weight) >0 ) { - moh =atomic_read (&most->activeconns) *50 - +atomic_read (&most->inactconns); + moh =ip_vs_dest_conn_overhead (most); goto nextstage; } }
@@ -239,8 +236,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set) nextstage:list_for_each_entry (e, &set->list, list) { dest = e->dest; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);/* moh/mw < doh/dw ==> moh*dw < doh*mw, where mw,dw>0 */ if ((moh *atomic_read (&dest->weight) < doh * atomic_read(&most->weight))
@@ -563,12 +559,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)int loh, doh;/* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!!
@@ -585,8 +576,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)if (atomic_read (&dest->weight) >0 ) { least = dest; - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }
@@ -600,8 +590,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if (loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) { least = dest;
net/netfilter/ipvs/ip_vs_lc.c +1 -17
@@ -22,22 +22,6 @@#include <net/ip_vs.h> - -static inline unsigned int -ip_vs_lc_dest_overhead (struct ip_vs_dest *dest) -{ -/* -* We think the overhead of processing active connections is 256 -* times higher than that of inactive connections in average. (This -* 256 times might not be accurate, we will change it later) We -* use the following formula to estimate the overhead now: -* dest->activeconns*256 + dest->inactconns -*/ -return (atomic_read (&dest->activeconns) <<8 ) + -atomic_read (&dest->inactconns); -} - -/* * Least Connection scheduling */
@@ -62,7 +46,7 @@ ip_vs_lc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if ((dest->flags &IP_VS_DEST_F_OVERLOAD ) ||atomic_read (&dest->weight) ==0 )continue ; - doh =ip_vs_lc_dest_overhead (dest); + doh =ip_vs_dest_conn_overhead (dest);if (!least || doh < loh) { least = dest; loh = doh;
net/netfilter/ipvs/ip_vs_wlc.c +0 -15
@@ -27,22 +27,6 @@#include <net/ip_vs.h> - -static inline unsigned int -ip_vs_wlc_dest_overhead (struct ip_vs_dest *dest) -{ -/* -* We think the overhead of processing active connections is 256 -* times higher than that of inactive connections in average. (This -* 256 times might not be accurate, we will change it later) We -* use the following formula to estimate the overhead now: -* dest->activeconns*256 + dest->inactconns -*/ -return (atomic_read (&dest->activeconns) <<8 ) + -atomic_read (&dest->inactconns); -} -
Simon Horman
maintainerQuoted 4 lines · Changli Gao
lc and wlc use the same formula, but lblc and lblcr use another one. There is no reason for using two different formulas for the lc variants.
The formula used by lc is used by all the lc variants in this patch.
Wensong, are you ok with this version of the patch?
Quoted 233 lines
Signed-off-by Changli Gao <[email protected]>---
v2: useip_vs_dest_conn_overhead()instead.include/net/ip_vs.h | 14 ++++++++++++++ net/netfilter/ipvs/ip_vs_lblc.c | 13 +++---------- net/netfilter/ipvs/ip_vs_lblcr.c | 25 +++++++------------------ net/netfilter/ipvs/ip_vs_lc.c | 18 +----------------- net/netfilter/ipvs/ip_vs_wlc.c | 20 ++------------------ 5 files changed, 27 insertions(+), 63 deletions(-)include/net/ip_vs.h +14
-0@@ -1241,6 +1241,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp)/* CONFIG_IP_VS_NFCT */ #endif +static inline unsigned int +ip_vs_dest_conn_overhead (struct ip_vs_dest *dest) +{ +/* +* We think the overhead of processing active connections is 256 +* times higher than that of inactive connections in average. (This +* 256 times might not be accurate, we will change it later) We +* use the following formula to estimate the overhead now: +* dest->activeconns*256 + dest->inactconns +*/ +return (atomic_read (&dest->activeconns) <<8 ) + +atomic_read (&dest->inactconns); +} +#endif /* __KERNEL__ */ #endif /* _NET_IP_VS_H */ net/netfilter/ipvs/ip_vs_lblc.c +3
-10@@ -389,12 +389,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)int loh, doh;/* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -410,8 +405,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)continue ;if (atomic_read (&dest->weight) >0 ) { least = dest; - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }@@ -425,8 +419,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if (loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lblcr.c +7
-18@@ -178,8 +178,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set)if ((atomic_read (&least->weight) >0 ) && (least->flags &IP_VS_DEST_F_AVAILABLE )) { - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }@@ -192,8 +191,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if ((loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) && (dest->flags &IP_VS_DEST_F_AVAILABLE )) {@@ -228,8 +226,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)list_for_each_entry (e, &set->list, list) { most = e->dest;if (atomic_read (&most->weight) >0 ) { - moh =atomic_read (&most->activeconns) *50 - +atomic_read (&most->inactconns); + moh =ip_vs_dest_conn_overhead (most); goto nextstage; } }@@ -239,8 +236,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set) nextstage:list_for_each_entry (e, &set->list, list) { dest = e->dest; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);/* moh/mw < doh/dw ==> moh*dw < doh*mw, where mw,dw>0 */ if ((moh *atomic_read (&dest->weight) < doh * atomic_read(&most->weight))@@ -563,12 +559,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)int loh, doh;/* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -585,8 +576,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)if (atomic_read (&dest->weight) >0 ) { least = dest; - loh =atomic_read (&least->activeconns) *50 - +atomic_read (&least->inactconns); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }@@ -600,8 +590,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc)if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =atomic_read (&dest->activeconns) *50 - +atomic_read (&dest->inactconns); + doh =ip_vs_dest_conn_overhead (dest);if (loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lc.c +1
-17@@ -22,22 +22,6 @@#include <net/ip_vs.h> - -static inline unsigned int -ip_vs_lc_dest_overhead (struct ip_vs_dest *dest) -{ -/* -* We think the overhead of processing active connections is 256 -* times higher than that of inactive connections in average. (This -* 256 times might not be accurate, we will change it later) We -* use the following formula to estimate the overhead now: -* dest->activeconns*256 + dest->inactconns -*/ -return (atomic_read (&dest->activeconns) <<8 ) + -atomic_read (&dest->inactconns); -} - -/* * Least Connection scheduling */ @@ -62,7 +46,7 @@ ip_vs_lc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if ((dest->flags &IP_VS_DEST_F_OVERLOAD ) ||atomic_read (&dest->weight) ==0 )continue ; - doh =ip_vs_lc_dest_overhead (dest); + doh =ip_vs_dest_conn_overhead (dest);if (!least || doh < loh) { least = dest; loh = doh;net/netfilter/ipvs/ip_vs_wlc.c +2
-18@@ -27,22 +27,6 @@#include <net/ip_vs.h> - -static inline unsigned int -ip_vs_wlc_dest_overhead (struct ip_vs_dest *dest) -{ -/* -* We think the overhead of processing active connections is 256 -* times higher than that of inactive connections in average. (This -* 256 times might not be accurate, we will change it later) We -* use the following formula to estimate the overhead now: -* dest->activeconns*256 + dest->inactconns -*/ -return (atomic_read (&dest->activeconns) <<8 ) + -atomic_read (&dest->inactconns); -} - -/* * Weighted Least Connection scheduling */ @@ -71,7 +55,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if (!(dest->flags &IP_VS_DEST_F_OVERLOAD ) &&atomic_read (&dest->weight) >0 ) { least = dest; - loh =ip_vs_wlc_dest_overhead (least); + loh =ip_vs_dest_conn_overhead (least); goto nextstage; } }@@ -85,7 +69,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)list_for_each_entry_continue (dest, &svc->destinations, n_list) {if (dest->flags &IP_VS_DEST_F_OVERLOAD )continue ; - doh =ip_vs_wlc_dest_overhead (dest); + doh =ip_vs_dest_conn_overhead (dest);if (loh *atomic_read (&dest->weight) > doh *atomic_read (&least->weight)) { least = dest;
Sure, I am ok with this patch. Thanks!
Quoted 233 lines · Simon Horman
Quoted 4 lines · Changli Gao
lc and wlc use the same formula, but lblc and lblcr use another one. There is no reason for using two different formulas for the lc variants.
The formula used by lc is used by all the lc variants in this patch.
Wensong, are you ok with this version of the patch?
Quoted 225 lines
Signed-off-by Changli Gao <[email protected]>---
v2: useip_vs_dest_conn_overhead()instead.include/net/ip_vs.h| 14 ++++++++++++++net/netfilter/ipvs/ip_vs_lblc.c| 13 +++----------net/netfilter/ipvs/ip_vs_lblcr.c| 25 +++++++------------------net/netfilter/ipvs/ip_vs_lc.c| 18 +-----------------net/netfilter/ipvs/ip_vs_wlc.c| 20 ++------------------5 files changed, 27 insertions(+), 63 deletions(-)include/net/ip_vs.h +14
-0@@ -1241,6 +1241,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp) /* CONFIG_IP_VS_NFCT */ #endif +static inline unsigned int +ip_vs_dest_conn_overhead (struct ip_vs_dest *dest) +{ + /* + * We think the overhead of processing active connections is 256 + * times higher than that of inactive connections in average. (This + * 256 times might not be accurate, we will change it later) We + * use the following formula to estimate the overhead now: + * dest->activeconns*256 + dest->inactconns + */ + return (atomic_read(&dest->activeconns) << 8) + + atomic_read(&dest->inactconns); +} + #endif /* __KERNEL__ */ #endif /* _NET_IP_VS_H */net/netfilter/ipvs/ip_vs_lblc.c +3
-10@@ -389,12 +389,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -410,8 +405,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) continue; if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -425,8 +419,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lblcr.c +2
-4@@ -178,8 +178,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if ((atomic_read(&least->weight) > 0) && (least->flags & IP_VS_DEST_F_AVAILABLE)) { - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -192,8 +191,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if ((loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) && (dest->flags&IP_VS_DEST_F_AVAILABLE)) {net/netfilter/ipvs/ip_vs_lblcr.c +1
-2@@ -228,8 +226,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set) list_for_each_entry(e, &set->list, list) { most = e->dest; if (atomic_read(&most->weight) > 0) { - moh = atomic_read(&most->activeconns) * 50 - + atomic_read(&most->inactconns); + moh = ip_vs_dest_conn_overhead(most); goto nextstage; } }@@ -239,8 +236,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)nextstage:
list_for_each_entry(e, &set->list, list){
dest =e->dest;
- doh =atomic_read(&dest->activeconns)* 50
- +atomic_read(&dest->inactconns);
+ doh =ip_vs_dest_conn_overhead(dest);
/* moh/mw < doh/dw ==> moh*dw < doh*mw, where mw,dw>0 */ if ((moh *atomic_read(&dest->weight)<
doh *atomic_read(&most->weight))net/netfilter/ipvs/ip_vs_lblcr.c +3
-10@@ -563,12 +559,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -585,8 +576,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -600,8 +590,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lc.c +0
-16@@ -22,22 +22,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_lc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Least Connection scheduling */ @@ -62,7 +46,7 @@ ip_vs_lc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if ((
dest->flags&IP_VS_DEST_F_OVERLOAD) ||atomic_read(&dest->weight)== 0) continue;
- doh =ip_vs_lc_dest_overhead(dest);
+ doh =ip_vs_dest_conn_overhead(dest); if (!least || doh < loh) {
least = dest;
loh = doh;net/netfilter/ipvs/ip_vs_wlc.c +0
-16@@ -27,22 +27,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_wlc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Weighted Least Connection scheduling */ @@ -71,7 +55,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if (!(dest->flags &
IP_VS_DEST_F_OVERLOAD) &&atomic_read(&dest->weight)> 0) { least = dest;
- loh =ip_vs_wlc_dest_overhead(least);
+ loh =ip_vs_dest_conn_overhead(least); goto nextstage;
}
}net/netfilter/ipvs/ip_vs_wlc.c +0
-0@@ -85,7 +69,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb) list_for_each_entry_continue(dest, &svc->destinations, n_list) {
Quoted 9 lines
Quoted 8 lines
net/netfilter/ipvs/ip_vs_wlc.c +1
-1if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = ip_vs_wlc_dest_overhead(dest); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;
--
To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Simon Horman
maintainerThanks, I will send a pull request to Patrick.
Quoted 246 lines · Wensong Zhang
Sure, I am ok with this patch. Thanks!
Quoted 242 lines · Simon Horman
Quoted 4 lines · Changli Gao
lc and wlc use the same formula, but lblc and lblcr use another one. There is no reason for using two different formulas for the lc variants.
The formula used by lc is used by all the lc variants in this patch.
Wensong, are you ok with this version of the patch?
Quoted 233 lines
Signed-off-by Changli Gao <[email protected]>---
v2: useip_vs_dest_conn_overhead()instead.include/net/ip_vs.h| 14 ++++++++++++++net/netfilter/ipvs/ip_vs_lblc.c| 13 +++----------net/netfilter/ipvs/ip_vs_lblcr.c| 25 +++++++------------------net/netfilter/ipvs/ip_vs_lc.c| 18 +-----------------net/netfilter/ipvs/ip_vs_wlc.c| 20 ++------------------5 files changed, 27 insertions(+), 63 deletions(-)include/net/ip_vs.h +14
-0@@ -1241,6 +1241,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp) /* CONFIG_IP_VS_NFCT */ #endif +static inline unsigned int +ip_vs_dest_conn_overhead (struct ip_vs_dest *dest) +{ + /* + * We think the overhead of processing active connections is 256 + * times higher than that of inactive connections in average. (This + * 256 times might not be accurate, we will change it later) We + * use the following formula to estimate the overhead now: + * dest->activeconns*256 + dest->inactconns + */ + return (atomic_read(&dest->activeconns) << 8) + + atomic_read(&dest->inactconns); +} + #endif /* __KERNEL__ */ #endif /* _NET_IP_VS_H */net/netfilter/ipvs/ip_vs_lblc.c +3
-10@@ -389,12 +389,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -410,8 +405,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) continue; if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -425,8 +419,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lblcr.c +2
-4@@ -178,8 +178,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if ((atomic_read(&least->weight) > 0) && (least->flags & IP_VS_DEST_F_AVAILABLE)) { - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -192,8 +191,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if ((loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) && (dest->flags&IP_VS_DEST_F_AVAILABLE)) {net/netfilter/ipvs/ip_vs_lblcr.c +1
-2@@ -228,8 +226,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set) list_for_each_entry(e, &set->list, list) { most = e->dest; if (atomic_read(&most->weight) > 0) { - moh = atomic_read(&most->activeconns) * 50 - + atomic_read(&most->inactconns); + moh = ip_vs_dest_conn_overhead(most); goto nextstage; } }@@ -239,8 +236,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)nextstage:
list_for_each_entry(e, &set->list, list){
dest =e->dest;
- doh =atomic_read(&dest->activeconns)* 50
- +atomic_read(&dest->inactconns);
+ doh =ip_vs_dest_conn_overhead(dest);
/* moh/mw < doh/dw ==> moh*dw < doh*mw, where mw,dw>0 */ if ((moh *atomic_read(&dest->weight)<
doh *atomic_read(&most->weight))net/netfilter/ipvs/ip_vs_lblcr.c +3
-10@@ -563,12 +559,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -585,8 +576,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -600,8 +590,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lc.c +0
-16@@ -22,22 +22,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_lc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Least Connection scheduling */ @@ -62,7 +46,7 @@ ip_vs_lc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if ((
dest->flags&IP_VS_DEST_F_OVERLOAD) ||atomic_read(&dest->weight)== 0) continue;
- doh =ip_vs_lc_dest_overhead(dest);
+ doh =ip_vs_dest_conn_overhead(dest); if (!least || doh < loh) {
least = dest;
loh = doh;net/netfilter/ipvs/ip_vs_wlc.c +0
-16@@ -27,22 +27,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_wlc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Weighted Least Connection scheduling */ @@ -71,7 +55,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if (!(dest->flags &
IP_VS_DEST_F_OVERLOAD) &&atomic_read(&dest->weight)> 0) { least = dest;
- loh =ip_vs_wlc_dest_overhead(least);
+ loh =ip_vs_dest_conn_overhead(least); goto nextstage;
}
}net/netfilter/ipvs/ip_vs_wlc.c +1
-1@@ -85,7 +69,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb) list_for_each_entry_continue(dest, &svc->destinations, n_list) { if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = ip_vs_wlc_dest_overhead(dest); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;
--
To unsubscribe from this list: send the line "unsubscribe netfilter-devel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Simon Horman
maintainerHi Wensong,
should I add an Acked-by?
Quoted 246 lines · Wensong Zhang
Sure, I am ok with this patch. Thanks!
Quoted 242 lines · Simon Horman
Quoted 4 lines · Changli Gao
lc and wlc use the same formula, but lblc and lblcr use another one. There is no reason for using two different formulas for the lc variants.
The formula used by lc is used by all the lc variants in this patch.
Wensong, are you ok with this version of the patch?
Quoted 233 lines
Signed-off-by Changli Gao <[email protected]>---
v2: useip_vs_dest_conn_overhead()instead.include/net/ip_vs.h| 14 ++++++++++++++net/netfilter/ipvs/ip_vs_lblc.c| 13 +++----------net/netfilter/ipvs/ip_vs_lblcr.c| 25 +++++++------------------net/netfilter/ipvs/ip_vs_lc.c| 18 +-----------------net/netfilter/ipvs/ip_vs_wlc.c| 20 ++------------------5 files changed, 27 insertions(+), 63 deletions(-)include/net/ip_vs.h +14
-0@@ -1241,6 +1241,20 @@ static inline void ip_vs_conn_drop_conntrack(struct ip_vs_conn *cp) /* CONFIG_IP_VS_NFCT */ #endif +static inline unsigned int +ip_vs_dest_conn_overhead (struct ip_vs_dest *dest) +{ + /* + * We think the overhead of processing active connections is 256 + * times higher than that of inactive connections in average. (This + * 256 times might not be accurate, we will change it later) We + * use the following formula to estimate the overhead now: + * dest->activeconns*256 + dest->inactconns + */ + return (atomic_read(&dest->activeconns) << 8) + + atomic_read(&dest->inactconns); +} + #endif /* __KERNEL__ */ #endif /* _NET_IP_VS_H */net/netfilter/ipvs/ip_vs_lblc.c +3
-10@@ -389,12 +389,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -410,8 +405,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) continue; if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -425,8 +419,7 @@ __ip_vs_lblc_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lblcr.c +2
-4@@ -178,8 +178,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if ((atomic_read(&least->weight) > 0) && (least->flags & IP_VS_DEST_F_AVAILABLE)) { - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -192,8 +191,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_min(struct ip_vs_dest_set *set) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if ((loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) && (dest->flags&IP_VS_DEST_F_AVAILABLE)) {net/netfilter/ipvs/ip_vs_lblcr.c +1
-2@@ -228,8 +226,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set) list_for_each_entry(e, &set->list, list) { most = e->dest; if (atomic_read(&most->weight) > 0) { - moh = atomic_read(&most->activeconns) * 50 - + atomic_read(&most->inactconns); + moh = ip_vs_dest_conn_overhead(most); goto nextstage; } }@@ -239,8 +236,7 @@ static inline struct ip_vs_dest *ip_vs_dest_set_max(struct ip_vs_dest_set *set)nextstage:
list_for_each_entry(e, &set->list, list){
dest =e->dest;
- doh =atomic_read(&dest->activeconns)* 50
- +atomic_read(&dest->inactconns);
+ doh =ip_vs_dest_conn_overhead(dest);
/* moh/mw < doh/dw ==> moh*dw < doh*mw, where mw,dw>0 */ if ((moh *atomic_read(&dest->weight)<
doh *atomic_read(&most->weight))net/netfilter/ipvs/ip_vs_lblcr.c +3
-10@@ -563,12 +559,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) int loh, doh; /* -* We think the overhead of processing active connections is fifty -* times higher than that of inactive connections in average. (This -* fifty times might not be accurate, we will change it later.) We -* use the following formula to estimate the overhead: -* dest->activeconns*50 + dest->inactconns -* and the load: +* We use the following formula to estimate the load: * (dest overhead) / dest->weight * * Remember -- no floats in kernel mode!!! @@ -585,8 +576,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (atomic_read(&dest->weight) > 0) { least = dest; - loh = atomic_read(&least->activeconns) * 50 - + atomic_read(&least->inactconns); + loh = ip_vs_dest_conn_overhead(least); goto nextstage; } }@@ -600,8 +590,7 @@ __ip_vs_lblcr_schedule(struct ip_vs_service *svc) if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = atomic_read(&dest->activeconns) * 50 - + atomic_read(&dest->inactconns); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;net/netfilter/ipvs/ip_vs_lc.c +0
-16@@ -22,22 +22,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_lc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Least Connection scheduling */ @@ -62,7 +46,7 @@ ip_vs_lc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if ((
dest->flags&IP_VS_DEST_F_OVERLOAD) ||atomic_read(&dest->weight)== 0) continue;
- doh =ip_vs_lc_dest_overhead(dest);
+ doh =ip_vs_dest_conn_overhead(dest); if (!least || doh < loh) {
least = dest;
loh = doh;net/netfilter/ipvs/ip_vs_wlc.c +0
-16@@ -27,22 +27,6 @@ #include <net/ip_vs.h> - -static inline unsigned int -ip_vs_wlc_dest_overhead (struct ip_vs_dest *dest) -{ - /* - * We think the overhead of processing active connections is 256 - * times higher than that of inactive connections in average. (This - * 256 times might not be accurate, we will change it later) We - * use the following formula to estimate the overhead now: - * dest->activeconns*256 + dest->inactconns - */ - return (atomic_read(&dest->activeconns) << 8) + - atomic_read(&dest->inactconns); -} - - /** Weighted Least Connection scheduling */ @@ -71,7 +55,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb)if (!(dest->flags &
IP_VS_DEST_F_OVERLOAD) &&atomic_read(&dest->weight)> 0) { least = dest;
- loh =ip_vs_wlc_dest_overhead(least);
+ loh =ip_vs_dest_conn_overhead(least); goto nextstage;
}
}net/netfilter/ipvs/ip_vs_wlc.c +1
-1@@ -85,7 +69,7 @@ ip_vs_wlc_schedule(struct ip_vs_service *svc, const struct sk_buff *skb) list_for_each_entry_continue(dest, &svc->destinations, n_list) { if (dest->flags & IP_VS_DEST_F_OVERLOAD) continue; - doh = ip_vs_wlc_dest_overhead(dest); + doh = ip_vs_dest_conn_overhead(dest);if (loh *
atomic_read(&dest->weight)> doh *atomic_read(&least->weight)) { least = dest;