per-container tcp buffer limitation
Subsystems (8)
Hello People,
[ For the ones in linux-mm that are receiving this for the first time,
this is a follow up of
http://thread.gmane.org/gmane.linux.kernel.containers/21295 ]
Here is a new, a bit more mature version of my previous RFC. Now I Request For More Comments from you guys in this new version of the patch.
Highlights:
* Although I do intend to experiment with more scenarios (suggestions welcome), there does not seem to be a (huge) performance hit with this patch applied, at least in a basic latency benchmark. That indicates that even if we can demonstrate a performance hit, it won't be too hard to optimize it away (famous last words?)
Since the patch touches both rcv and snd sides, I benchmarked it with netperf against localhost. Command line: netperf -t TCP_RR -H localhost.
Without the patch
=================
Socket Size Request Resp. Elapsed Trans. Send Recv Size Size Time Rate bytes Bytes bytes bytes secs. per sec
16384 87380 1 1 10.00 26996.35
16384 87380
With the patch
===============
Local /Remote
Socket Size Request Resp. Elapsed Trans. Send Recv Size Size Time Rate bytes Bytes bytes bytes secs. per sec
16384 87380 1 1 10.00 27291.86
16384 87380
As you can see, rate is a bit higher, but still under an one percent range, meaning it is basically unchanged. I will benchmark it with various levels of cgroup nesting on my next submission so we can have a better idea of the impact of it when enabled.
* As nicely pointed out by Kamezawa, I dropped the sockets cgroup, and introduced a kmem cgroup. After careful consideration, I decided not to reuse the memcg. Basically, my impression is that memcg is concerned with user objects, with page granularity and its swap attributes. Because kernel objects are entirely different, I prefer to group them here.
* Only tcp ipv4 is converted - because it is basically the one in which
memory pressure thresholds are really put to use. I plan to touch the other protocols in the next submission.
* As with other sysctls, the sysctl controlling tcp memory pressure behaviour was made per-netns. But it will show cgroup-data for the current cgroup. The cgroup control file, however, will only set a maximum value. The pressure thresholds is not the business of the box administrator, but rather, of the container's - anything goes, provided none of the 3 values go over the maximum.
Comments welcome
include/linux/cgroup_subsys.h +4 -0
@@ -35,6 +35,10 @@ SUBSYS(cpuacct) SUBSYS(mem_cgroup)#endif +#ifdef CONFIG_CGROUP_KMEM +SUBSYS(kmem) +#endif +/* */ #ifdef CONFIG_CGROUP_DEVICE
include/linux/kmem_cgroup.h new file +68 -0
68 lines not on this page · raw message
include/net/netns/ipv4.h +1 -0
@@ -55,6 +55,7 @@ struct netns_ipv4 {int current_rt_cache_rebuild_count;unsigned int sysctl_ping_group_range[2 ]; +long sysctl_tcp_mem[3 ];atomic_t rt_genid;atomic_t dev_addr_genid;
include/net/sock.h +59 -4
94 lines not on this page · raw message
include/net/tcp.h +8 -3
@@ -230,7 +230,6 @@ extern int sysctl_tcp_fack;extern int sysctl_tcp_reordering;extern int sysctl_tcp_ecn;extern int sysctl_tcp_dsack; -extern long sysctl_tcp_mem[3 ];extern int sysctl_tcp_wmem[3 ];extern int sysctl_tcp_rmem[3 ];extern int sysctl_tcp_app_win;
@@ -255,7 +254,13 @@ extern int sysctl_tcp_thin_dupack;extern atomic_long_t tcp_memory_allocated;extern struct percpu_counter tcp_sockets_allocated; -extern int tcp_memory_pressure; + +struct kmem_cgroup ; +extern long *tcp_sysctl_mem (struct kmem_cgroup *sg); +struct percpu_counter *sockets_allocated_tcp (struct kmem_cgroup *sg); +int *memory_pressure_tcp (struct kmem_cgroup *sg); +int tcp_init_cgroup (struct cgroup *cgrp,struct cgroup_subsys *ss); +atomic_long_t *memory_allocated_tcp (struct kmem_cgroup *sg);/* * The next routines deal with comparing 32 bit unsigned ints
@@ -286,7 +291,7 @@ static inline bool tcp_too_many_orphans(struct sock *sk, int shift) }if (sk->sk_wmem_queued >SOCK_MIN_SNDBUF && -atomic_long_read (&tcp_memory_allocated) > sysctl_tcp_mem[2 ]) +atomic_long_read (sk_memory_allocated (sk)) >sk_prot_mem (sk)[2 ])return true;return false; }
include/trace/events/sock.h +8 -7
@@ -31,13 +31,14 @@ TRACE_EVENT(sock_rcvqueue_full, TRACE_EVENT(sock_exceed_buf_limit, - TP_PROTO(struct sock *sk, struct proto *prot, long allocated), + TP_PROTO(struct sock *sk, struct proto *prot, long allocated, + long *prot_mem), - TP_ARGS(sk, prot, allocated), + TP_ARGS(sk, prot, allocated, prot_mem), TP_STRUCT__entry( __array(char, name, 32) - __field(long *, sysctl_mem) + __field(long *, prot_mem) __field(long, allocated) __field(int, sysctl_rmem) __field(int, rmem_alloc)
@@ -45,7 +46,7 @@ TRACE_EVENT(sock_exceed_buf_limit,TP_fast_assign ( strncpy(__entry->name, prot->name, 32); - __entry->sysctl_mem = prot->sysctl_mem; + __entry->prot_mem = prot_mem; __entry->allocated = allocated; __entry->sysctl_rmem = prot->sysctl_rmem[0 ]; __entry->rmem_alloc =atomic_read (&sk->sk_rmem_alloc);
@@ -54,9 +55,9 @@ TRACE_EVENT(sock_exceed_buf_limit,TP_printk ("proto:%s sysctl_mem=%ld,%ld,%ld allocated=%ld " "sysctl_rmem=%d rmem_alloc=%d" , __entry->name, - __entry->sysctl_mem[0 ], - __entry->sysctl_mem[1 ], - __entry->sysctl_mem[2 ], + __entry->prot_mem[0 ], + __entry->prot_mem[1 ], + __entry->prot_mem[2 ], __entry->allocated, __entry->sysctl_rmem, __entry->rmem_alloc)
init/Kconfig +11 -0
@@ -690,6 +690,17 @@ config CGROUP_MEM_RES_CTLR_SWAP_ENABLED select this option (if, for some reason, they need to disable it then swapaccount=0 does the trick). +config CGROUP_KMEM + bool "Kernel Memory Resource Controller for Control Groups" + depends on CGROUPS + help + The Kernel Memory cgroup can limit the amount of memory used by + certain kernel objects in the system. Those are fundamentally + different from the entities handled by the Memory Controller, + which are page-based, and can be swapped. Users of the kmem + cgroup can use it to guarantee that no group of processes will + ever exhaust kernel resources alone. + config CGROUP_PERF bool "Enable perf_event per-cpu per-container group (cgroup) monitoring" depends on PERF_EVENTS && CGROUPS
mm/Makefile +1 -0
@@ -45,6 +45,7 @@ obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_QUICKLIST) += quicklist.o obj-$(CONFIG_TRANSPARENT_HUGEPAGE) += huge_memory.o obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o +obj-$(CONFIG_CGROUP_KMEM) += kmem_cgroup.o obj-$(CONFIG_MEMORY_FAILURE) += memory-failure.o obj-$(CONFIG_HWPOISON_INJECT) += hwpoison-inject.o obj-$(CONFIG_DEBUG_KMEMLEAK) += kmemleak.o
mm/kmem_cgroup.c new file +53 -0
53 lines not on this page · raw message
net/core/sock.c +96 -27
211 lines not on this page · raw message
net/ipv4/proc.c +5 -3
@@ -53,19 +53,21 @@ static int sockstat_seq_show(struct seq_file *seq, void *v)struct net *net = seq->private;int orphans, sockets; +struct kmem_cgroup *sg =task_sk (current); +local_bh_disable (); orphans =percpu_counter_sum_positive (&tcp_orphan_count); - sockets =percpu_counter_sum_positive (&tcp_sockets_allocated); + sockets =percpu_counter_sum_positive (sg_sockets_allocated ((&tcp_prot), sg));local_bh_enable ();socket_seq_show (seq);seq_printf (seq,"TCP: inuse %d orphan %d tw %d alloc %d mem %ld\n" ,sock_prot_inuse_get (net, &tcp_prot), orphans, tcp_death_row.tw_count, sockets, -atomic_long_read (&tcp_memory_allocated)); +atomic_long_read (sg_memory_allocated ((&tcp_prot), sg)));seq_printf (seq,"UDP: inuse %d mem %ld\n" ,sock_prot_inuse_get (net, &udp_prot), -atomic_long_read (&udp_memory_allocated)); +atomic_long_read (sg_memory_allocated ((&udp_prot), sg)));seq_printf (seq,"UDPLITE: inuse %d\n" ,sock_prot_inuse_get (net, &udplite_prot)); seq_printf(seq, "RAW: inuse %d\n",
net/ipv4/sysctl_net_ipv4.c +52 -7
95 lines not on this page · raw message
net/ipv4/tcp.c +144 -21
217 lines not on this page · raw message
net/ipv4/tcp_input.c +9 -8
@@ -316,7 +316,7 @@ static void tcp_grow_window(struct sock *sk, struct sk_buff *skb)/* Check #1 */ if (tp->rcv_ssthresh < tp->window_clamp && (int )tp->rcv_ssthresh <tcp_space (sk) && - !tcp_memory_pressure) { + !sk_memory_pressure (sk)) {int incr;/* Check #2. Increase window, if skb with such overhead
@@ -393,15 +393,16 @@ static void tcp_clamp_window(struct sock *sk) {struct tcp_sock *tp =tcp_sk (sk);struct inet_connection_sock *icsk =inet_csk (sk); +struct proto *prot = sk->sk_prot; icsk->icsk_ack.quick =0 ; -if (sk->sk_rcvbuf < sysctl_tcp_rmem[2 ] && +if (sk->sk_rcvbuf < prot->sysctl_rmem[2 ] && !(sk->sk_userlocks &SOCK_RCVBUF_LOCK ) && - !tcp_memory_pressure && -atomic_long_read (&tcp_memory_allocated) < sysctl_tcp_mem[0 ]) { + !sk_memory_pressure (sk) && +atomic_long_read (sk_memory_allocated (sk)) <sk_prot_mem (sk)[0 ]) { sk->sk_rcvbuf =min (atomic_read (&sk->sk_rmem_alloc), - sysctl_tcp_rmem[2 ]); + prot->sysctl_rmem[2 ]); }if (atomic_read (&sk->sk_rmem_alloc) > sk->sk_rcvbuf) tp->rcv_ssthresh =min (tp->window_clamp,2U * tp->advmss);
@@ -4806,7 +4807,7 @@ static int tcp_prune_queue(struct sock *sk)if (atomic_read (&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)tcp_clamp_window (sk); -else if (tcp_memory_pressure) +else if (sk_memory_pressure (sk)) tp->rcv_ssthresh =min (tp->rcv_ssthresh,4U * tp->advmss);tcp_collapse_ofo_queue (sk);
@@ -4872,11 +4873,11 @@ static int tcp_should_expand_sndbuf(struct sock *sk)return 0 ;/* If we are under global TCP memory pressure, do not expand. */ -if (tcp_memory_pressure) +if (sk_memory_pressure (sk))return 0 ;/* If we are under soft global TCP memory pressure, do not expand. */ -if (atomic_long_read (&tcp_memory_allocated) >= sysctl_tcp_mem[0 ]) +if (atomic_long_read (sk_memory_allocated (sk)) >=sk_prot_mem (sk)[0 ])return 0 ;/* If we filled the congestion window, do not expand. */
net/ipv4/tcp_ipv4.c +9 -6
@@ -1901,7 +1901,7 @@ static int tcp_v4_init_sock(struct sock *sk) sk->sk_rcvbuf = sysctl_tcp_rmem[1 ];local_bh_disable (); -percpu_counter_inc (&tcp_sockets_allocated); +percpu_counter_inc (sk_sockets_allocated (sk));local_bh_enable ();return 0 ;
@@ -1957,7 +1957,7 @@ void tcp_v4_destroy_sock(struct sock *sk) tp->cookie_values =NULL ; } -percpu_counter_dec (&tcp_sockets_allocated); +percpu_counter_dec (sk_sockets_allocated (sk)); }EXPORT_SYMBOL (tcp_v4_destroy_sock);
@@ -2598,11 +2598,14 @@ struct proto tcp_prot = { .unhash = inet_unhash, .get_port = inet_csk_get_port, .enter_memory_pressure = tcp_enter_memory_pressure, - .sockets_allocated = &tcp_sockets_allocated, + .memory_pressure = memory_pressure_tcp, + .sockets_allocated = sockets_allocated_tcp, .orphan_count = &tcp_orphan_count, - .memory_allocated = &tcp_memory_allocated, - .memory_pressure = &tcp_memory_pressure, - .sysctl_mem = sysctl_tcp_mem, + .memory_allocated = memory_allocated_tcp, +#ifdef CONFIG_CGROUP_KMEM + .init_cgroup = tcp_init_cgroup, +#endif + .prot_mem = tcp_sysctl_mem, .sysctl_wmem = sysctl_tcp_wmem, .sysctl_rmem = sysctl_tcp_rmem, .max_header = MAX_TCP_HEADER,
net/ipv4/tcp_output.c +1 -1
@@ -1912,7 +1912,7 @@ u32 __tcp_select_window(struct sock *sk)if (free_space < (full_space >>1 )) { icsk->icsk_ack.quick =0 ; -if (tcp_memory_pressure) +if (sk_memory_pressure (sk)) tp->rcv_ssthresh =min (tp->rcv_ssthresh,4U * tp->advmss);
net/ipv4/tcp_timer.c +1 -1
@@ -261,7 +261,7 @@ static void tcp_delack_timer(unsigned long data) } out: -if (tcp_memory_pressure) +if (sk_memory_pressure (sk))sk_mem_reclaim (sk); out_unlock:bh_unlock_sock (sk);
net/ipv4/udp.c +20 -5
@@ -120,9 +120,6 @@ EXPORT_SYMBOL(sysctl_udp_rmem_min);int sysctl_udp_wmem_min__read_mostly ;EXPORT_SYMBOL (sysctl_udp_wmem_min); -atomic_long_t udp_memory_allocated; -EXPORT_SYMBOL (udp_memory_allocated); -#define MAX_UDP_PORTS 65536#define PORTS_PER_CHAIN (MAX_UDP_PORTS / UDP_HTABLE_SIZE_MIN)
@@ -1918,6 +1915,24 @@ unsigned int udp_poll(struct file *file, struct socket *sock, poll_table *wait) }EXPORT_SYMBOL (udp_poll); +#ifdef CONFIG_CGROUP_KMEM +static atomic_long_t *memory_allocated_udp (struct kmem_cgroup *sg) +{ +return &sg->udp_memory_allocated; +} +#else +atomic_long_t udp_memory_allocated; +static atomic_long_t *memory_allocated_udp (struct kmem_cgroup *sg) +{ +return &udp_memory_allocated; +} +#endif + +static long *udp_sysctl_mem (struct kmem_cgroup *sg) +{ +return sysctl_udp_mem; +} +struct proto udp_prot = { .name ="UDP" , .owner =THIS_MODULE ,
@@ -1936,8 +1951,8 @@ struct proto udp_prot = { .unhash = udp_lib_unhash, .rehash = udp_v4_rehash, .get_port = udp_v4_get_port, - .memory_allocated = &udp_memory_allocated, - .sysctl_mem = sysctl_udp_mem, + .memory_allocated = &memory_allocated_udp, + .prot_mem = udp_sysctl_mem, .sysctl_wmem = &sysctl_udp_wmem_min, .sysctl_rmem = &sysctl_udp_rmem_min, .obj_size = sizeof(struct udp_sock),
Quoted 38 lines · On Wed, 31 Aug 2011 23:43:27 -0300 Glauber Costa <[email protected]> wrote:
Hello People,
[ For the ones in linux-mm that are receiving this for the first time,
this is a follow up of
http://thread.gmane.org/gmane.linux.kernel.containers/21295 ]Here is a new, a bit more mature version of my previous RFC. Now I Request For More Comments from you guys in this new version of the patch.
Highlights:
* Although I do intend to experiment with more scenarios (suggestions welcome), there does not seem to be a (huge) performance hit with this patch applied, at least in a basic latency benchmark. That indicates that even if we can demonstrate a performance hit, it won't be too hard to optimize it away (famous last words?)
Since the patch touches both rcv and snd sides, I benchmarked it with netperf against localhost. Command line: netperf -t
TCP_RR-H localhost.Without the patch
=================Socket Size Request Resp. Elapsed Trans. Send Recv Size Size Time Rate bytes Bytes bytes bytes secs. per sec16384 87380 1 1 10.00 26996.35
16384 87380With the patch
===============Local /Remote
Socket Size Request Resp. Elapsed Trans. Send Recv Size Size Time Rate bytes Bytes bytes bytes secs. per sec
Quoted 9 lines
16384 87380 1 1 10.00 27291.86
16384 87380As you can see, rate is a bit higher, but still under an one percent range, meaning it is basically unchanged. I will benchmark it with various levels of cgroup nesting on my next submission so we can have a better idea of the impact of it when enabled.
seems nice.
Quoted 6 lines
* As nicely pointed out by Kamezawa, I dropped the sockets cgroup, and introduced a kmem cgroup. After careful consideration, I decided not to reuse the memcg. Basically, my impression is that memcg is concerned with user objects, with page granularity and its swap attributes. Because kernel objects are entirely different, I prefer to group them here.
I myself has no objection to this direction. Other guys ?
Thanks,
-Kame
--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Fight unfair telecom internet charges in Canada: sign http://stopthemeter.ca/
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>