About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Documentation / controllers / memory.txt




Custom Search

Based on kernel version 2.6.27. Page generated on 2008-10-13 09:53 EST.

1	Memory Resource Controller
2	
3	NOTE: The Memory Resource Controller has been generically been referred
4	to as the memory controller in this document. Do not confuse memory controller
5	used here with the memory controller that is used in hardware.
6	
7	Salient features
8	
9	a. Enable control of both RSS (mapped) and Page Cache (unmapped) pages
10	b. The infrastructure allows easy addition of other types of memory to control
11	c. Provides *zero overhead* for non memory controller users
12	d. Provides a double LRU: global memory pressure causes reclaim from the
13	   global LRU; a cgroup on hitting a limit, reclaims from the per
14	   cgroup LRU
15	
16	NOTE: Swap Cache (unmapped) is not accounted now.
17	
18	Benefits and Purpose of the memory controller
19	
20	The memory controller isolates the memory behaviour of a group of tasks
21	from the rest of the system. The article on LWN [12] mentions some probable
22	uses of the memory controller. The memory controller can be used to
23	
24	a. Isolate an application or a group of applications
25	   Memory hungry applications can be isolated and limited to a smaller
26	   amount of memory.
27	b. Create a cgroup with limited amount of memory, this can be used
28	   as a good alternative to booting with mem=XXXX.
29	c. Virtualization solutions can control the amount of memory they want
30	   to assign to a virtual machine instance.
31	d. A CD/DVD burner could control the amount of memory used by the
32	   rest of the system to ensure that burning does not fail due to lack
33	   of available memory.
34	e. There are several other use cases, find one or use the controller just
35	   for fun (to learn and hack on the VM subsystem).
36	
37	1. History
38	
39	The memory controller has a long history. A request for comments for the memory
40	controller was posted by Balbir Singh [1]. At the time the RFC was posted
41	there were several implementations for memory control. The goal of the
42	RFC was to build consensus and agreement for the minimal features required
43	for memory control. The first RSS controller was posted by Balbir Singh[2]
44	in Feb 2007. Pavel Emelianov [3][4][5] has since posted three versions of the
45	RSS controller. At OLS, at the resource management BoF, everyone suggested
46	that we handle both page cache and RSS together. Another request was raised
47	to allow user space handling of OOM. The current memory controller is
48	at version 6; it combines both mapped (RSS) and unmapped Page
49	Cache Control [11].
50	
51	2. Memory Control
52	
53	Memory is a unique resource in the sense that it is present in a limited
54	amount. If a task requires a lot of CPU processing, the task can spread
55	its processing over a period of hours, days, months or years, but with
56	memory, the same physical memory needs to be reused to accomplish the task.
57	
58	The memory controller implementation has been divided into phases. These
59	are:
60	
61	1. Memory controller
62	2. mlock(2) controller
63	3. Kernel user memory accounting and slab control
64	4. user mappings length controller
65	
66	The memory controller is the first controller developed.
67	
68	2.1. Design
69	
70	The core of the design is a counter called the res_counter. The res_counter
71	tracks the current memory usage and limit of the group of processes associated
72	with the controller. Each cgroup has a memory controller specific data
73	structure (mem_cgroup) associated with it.
74	
75	2.2. Accounting
76	
77			+--------------------+
78			|  mem_cgroup     |
79			|  (res_counter)     |
80			+--------------------+
81			 /            ^      \
82			/             |       \
83	           +---------------+  |        +---------------+
84	           | mm_struct     |  |....    | mm_struct     |
85	           |               |  |        |               |
86	           +---------------+  |        +---------------+
87	                              |
88	                              + --------------+
89	                                              |
90	           +---------------+           +------+--------+
91	           | page          +---------->  page_cgroup|
92	           |               |           |               |
93	           +---------------+           +---------------+
94	
95	             (Figure 1: Hierarchy of Accounting)
96	
97	
98	Figure 1 shows the important aspects of the controller
99	
100	1. Accounting happens per cgroup
101	2. Each mm_struct knows about which cgroup it belongs to
102	3. Each page has a pointer to the page_cgroup, which in turn knows the
103	   cgroup it belongs to
104	
105	The accounting is done as follows: mem_cgroup_charge() is invoked to setup
106	the necessary data structures and check if the cgroup that is being charged
107	is over its limit. If it is then reclaim is invoked on the cgroup.
108	More details can be found in the reclaim section of this document.
109	If everything goes well, a page meta-data-structure called page_cgroup is
110	allocated and associated with the page.  This routine also adds the page to
111	the per cgroup LRU.
112	
113	2.2.1 Accounting details
114	
115	All mapped pages (RSS) and unmapped user pages (Page Cache) are accounted.
116	RSS pages are accounted at the time of page_add_*_rmap() unless they've already
117	been accounted for earlier. A file page will be accounted for as Page Cache;
118	it's mapped into the page tables of a process, duplicate accounting is carefully
119	avoided. Page Cache pages are accounted at the time of add_to_page_cache().
120	The corresponding routines that remove a page from the page tables or removes
121	a page from Page Cache is used to decrement the accounting counters of the
122	cgroup.
123	
124	2.3 Shared Page Accounting
125	
126	Shared pages are accounted on the basis of the first touch approach. The
127	cgroup that first touches a page is accounted for the page. The principle
128	behind this approach is that a cgroup that aggressively uses a shared
129	page will eventually get charged for it (once it is uncharged from
130	the cgroup that brought it in -- this will happen on memory pressure).
131	
132	2.4 Reclaim
133	
134	Each cgroup maintains a per cgroup LRU that consists of an active
135	and inactive list. When a cgroup goes over its limit, we first try
136	to reclaim memory from the cgroup so as to make space for the new
137	pages that the cgroup has touched. If the reclaim is unsuccessful,
138	an OOM routine is invoked to select and kill the bulkiest task in the
139	cgroup.
140	
141	The reclaim algorithm has not been modified for cgroups, except that
142	pages that are selected for reclaiming come from the per cgroup LRU
143	list.
144	
145	2. Locking
146	
147	The memory controller uses the following hierarchy
148	
149	1. zone->lru_lock is used for selecting pages to be isolated
150	2. mem->per_zone->lru_lock protects the per cgroup LRU (per zone)
151	3. lock_page_cgroup() is used to protect page->page_cgroup
152	
153	3. User Interface
154	
155	0. Configuration
156	
157	a. Enable CONFIG_CGROUPS
158	b. Enable CONFIG_RESOURCE_COUNTERS
159	c. Enable CONFIG_CGROUP_MEM_RES_CTLR
160	
161	1. Prepare the cgroups
162	# mkdir -p /cgroups
163	# mount -t cgroup none /cgroups -o memory
164	
165	2. Make the new group and move bash into it
166	# mkdir /cgroups/0
167	# echo $$ >  /cgroups/0/tasks
168	
169	Since now we're in the 0 cgroup,
170	We can alter the memory limit:
171	# echo 4M > /cgroups/0/memory.limit_in_bytes
172	
173	NOTE: We can use a suffix (k, K, m, M, g or G) to indicate values in kilo,
174	mega or gigabytes.
175	
176	# cat /cgroups/0/memory.limit_in_bytes
177	4194304
178	
179	NOTE: The interface has now changed to display the usage in bytes
180	instead of pages
181	
182	We can check the usage:
183	# cat /cgroups/0/memory.usage_in_bytes
184	1216512
185	
186	A successful write to this file does not guarantee a successful set of
187	this limit to the value written into the file.  This can be due to a
188	number of factors, such as rounding up to page boundaries or the total
189	availability of memory on the system.  The user is required to re-read
190	this file after a write to guarantee the value committed by the kernel.
191	
192	# echo 1 > memory.limit_in_bytes
193	# cat memory.limit_in_bytes
194	4096
195	
196	The memory.failcnt field gives the number of times that the cgroup limit was
197	exceeded.
198	
199	The memory.stat file gives accounting information. Now, the number of
200	caches, RSS and Active pages/Inactive pages are shown.
201	
202	The memory.force_empty gives an interface to drop *all* charges by force.
203	
204	# echo 1 > memory.force_empty
205	
206	will drop all charges in cgroup. Currently, this is maintained for test.
207	
208	4. Testing
209	
210	Balbir posted lmbench, AIM9, LTP and vmmstress results [10] and [11].
211	Apart from that v6 has been tested with several applications and regular
212	daily use. The controller has also been tested on the PPC64, x86_64 and
213	UML platforms.
214	
215	4.1 Troubleshooting
216	
217	Sometimes a user might find that the application under a cgroup is
218	terminated. There are several causes for this:
219	
220	1. The cgroup limit is too low (just too low to do anything useful)
221	2. The user is using anonymous memory and swap is turned off or too low
222	
223	A sync followed by echo 1 > /proc/sys/vm/drop_caches will help get rid of
224	some of the pages cached in the cgroup (page cache pages).
225	
226	4.2 Task migration
227	
228	When a task migrates from one cgroup to another, it's charge is not
229	carried forward. The pages allocated from the original cgroup still
230	remain charged to it, the charge is dropped when the page is freed or
231	reclaimed.
232	
233	4.3 Removing a cgroup
234	
235	A cgroup can be removed by rmdir, but as discussed in sections 4.1 and 4.2, a
236	cgroup might have some charge associated with it, even though all
237	tasks have migrated away from it. Such charges are automatically dropped at
238	rmdir() if there are no tasks.
239	
240	5. TODO
241	
242	1. Add support for accounting huge pages (as a separate controller)
243	2. Make per-cgroup scanner reclaim not-shared pages first
244	3. Teach controller to account for shared-pages
245	4. Start reclamation in the background when the limit is
246	   not yet hit but the usage is getting closer
247	
248	Summary
249	
250	Overall, the memory controller has been a stable controller and has been
251	commented and discussed quite extensively in the community.
252	
253	References
254	
255	1. Singh, Balbir. RFC: Memory Controller, http://lwn.net/Articles/206697/
256	2. Singh, Balbir. Memory Controller (RSS Control),
257	   http://lwn.net/Articles/222762/
258	3. Emelianov, Pavel. Resource controllers based on process cgroups
259	   http://lkml.org/lkml/2007/3/6/198
260	4. Emelianov, Pavel. RSS controller based on process cgroups (v2)
261	   http://lkml.org/lkml/2007/4/9/78
262	5. Emelianov, Pavel. RSS controller based on process cgroups (v3)
263	   http://lkml.org/lkml/2007/5/30/244
264	6. Menage, Paul. Control Groups v10, http://lwn.net/Articles/236032/
265	7. Vaidyanathan, Srinivasan, Control Groups: Pagecache accounting and control
266	   subsystem (v3), http://lwn.net/Articles/235534/
267	8. Singh, Balbir. RSS controller v2 test results (lmbench),
268	   http://lkml.org/lkml/2007/5/17/232
269	9. Singh, Balbir. RSS controller v2 AIM9 results
270	   http://lkml.org/lkml/2007/5/18/1
271	10. Singh, Balbir. Memory controller v6 test results,
272	    http://lkml.org/lkml/2007/8/19/36
273	11. Singh, Balbir. Memory controller introduction (v6),
274	    http://lkml.org/lkml/2007/8/17/69
275	12. Corbet, Jonathan, Controlling memory use in cgroups,
276	    http://lwn.net/Articles/243795/
Hide Line Numbers
About Kernel Documentation Linux Kernel Contact Linux Resources Linux Blog

Information is copyright its respective author. All material is available from the Linux Kernel Source distributed under a GPL License. This page is provided as a free service by mjmwired.net.