Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  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 Anonymous, Page Cache (mapped and unmapped) and
 10    Swap Cache memory pages.
 11 b. The infrastructure allows easy addition of other types of memory to control
 12 c. Provides *zero overhead* for non memory controller users
 13 d. Provides a double LRU: global memory pressure causes reclaim from the
 14    global LRU; a cgroup on hitting a limit, reclaims from the per
 15    cgroup LRU
 16 
 17 Benefits and Purpose of the memory controller
 18 
 19 The memory controller isolates the memory behaviour of a group of tasks
 20 from the rest of the system. The article on LWN [12] mentions some probable
 21 uses of the memory controller. The memory controller can be used to
 22 
 23 a. Isolate an application or a group of applications
 24    Memory hungry applications can be isolated and limited to a smaller
 25    amount of memory.
 26 b. Create a cgroup with limited amount of memory, this can be used
 27    as a good alternative to booting with mem=XXXX.
 28 c. Virtualization solutions can control the amount of memory they want
 29    to assign to a virtual machine instance.
 30 d. A CD/DVD burner could control the amount of memory used by the
 31    rest of the system to ensure that burning does not fail due to lack
 32    of available memory.
 33 e. There are several other use cases, find one or use the controller just
 34    for fun (to learn and hack on the VM subsystem).
 35 
 36 1. History
 37 
 38 The memory controller has a long history. A request for comments for the memory
 39 controller was posted by Balbir Singh [1]. At the time the RFC was posted
 40 there were several implementations for memory control. The goal of the
 41 RFC was to build consensus and agreement for the minimal features required
 42 for memory control. The first RSS controller was posted by Balbir Singh[2]
 43 in Feb 2007. Pavel Emelianov [3][4][5] has since posted three versions of the
 44 RSS controller. At OLS, at the resource management BoF, everyone suggested
 45 that we handle both page cache and RSS together. Another request was raised
 46 to allow user space handling of OOM. The current memory controller is
 47 at version 6; it combines both mapped (RSS) and unmapped Page
 48 Cache Control [11].
 49 
 50 2. Memory Control
 51 
 52 Memory is a unique resource in the sense that it is present in a limited
 53 amount. If a task requires a lot of CPU processing, the task can spread
 54 its processing over a period of hours, days, months or years, but with
 55 memory, the same physical memory needs to be reused to accomplish the task.
 56 
 57 The memory controller implementation has been divided into phases. These
 58 are:
 59 
 60 1. Memory controller
 61 2. mlock(2) controller
 62 3. Kernel user memory accounting and slab control
 63 4. user mappings length controller
 64 
 65 The memory controller is the first controller developed.
 66 
 67 2.1. Design
 68 
 69 The core of the design is a counter called the res_counter. The res_counter
 70 tracks the current memory usage and limit of the group of processes associated
 71 with the controller. Each cgroup has a memory controller specific data
 72 structure (mem_cgroup) associated with it.
 73 
 74 2.2. Accounting
 75 
 76                 +--------------------+
 77                 |  mem_cgroup     |
 78                 |  (res_counter)     |
 79                 +--------------------+
 80                  /            ^      \
 81                 /             |       \
 82            +---------------+  |        +---------------+
 83            | mm_struct     |  |....    | mm_struct     |
 84            |               |  |        |               |
 85            +---------------+  |        +---------------+
 86                               |
 87                               + --------------+
 88                                               |
 89            +---------------+           +------+--------+
 90            | page          +---------->  page_cgroup|
 91            |               |           |               |
 92            +---------------+           +---------------+
 93 
 94              (Figure 1: Hierarchy of Accounting)
 95 
 96 
 97 Figure 1 shows the important aspects of the controller
 98 
 99 1. Accounting happens per cgroup
100 2. Each mm_struct knows about which cgroup it belongs to
101 3. Each page has a pointer to the page_cgroup, which in turn knows the
102    cgroup it belongs to
103 
104 The accounting is done as follows: mem_cgroup_charge() is invoked to setup
105 the necessary data structures and check if the cgroup that is being charged
106 is over its limit. If it is then reclaim is invoked on the cgroup.
107 More details can be found in the reclaim section of this document.
108 If everything goes well, a page meta-data-structure called page_cgroup is
109 allocated and associated with the page.  This routine also adds the page to
110 the per cgroup LRU.
111 
112 2.2.1 Accounting details
113 
114 All mapped anon pages (RSS) and cache pages (Page Cache) are accounted.
115 (some pages which never be reclaimable and will not be on global LRU
116  are not accounted. we just accounts pages under usual vm management.)
117 
118 RSS pages are accounted at page_fault unless they've already been accounted
119 for earlier. A file page will be accounted for as Page Cache when it's
120 inserted into inode (radix-tree). While it's mapped into the page tables of
121 processes, duplicate accounting is carefully avoided.
122 
123 A RSS page is unaccounted when it's fully unmapped. A PageCache page is
124 unaccounted when it's removed from radix-tree.
125 
126 At page migration, accounting information is kept.
127 
128 Note: we just account pages-on-lru because our purpose is to control amount
129 of used pages. not-on-lru pages are tend to be out-of-control from vm view.
130 
131 2.3 Shared Page Accounting
132 
133 Shared pages are accounted on the basis of the first touch approach. The
134 cgroup that first touches a page is accounted for the page. The principle
135 behind this approach is that a cgroup that aggressively uses a shared
136 page will eventually get charged for it (once it is uncharged from
137 the cgroup that brought it in -- this will happen on memory pressure).
138 
139 Exception: If CONFIG_CGROUP_CGROUP_MEM_RES_CTLR_SWAP is not used..
140 When you do swapoff and make swapped-out pages of shmem(tmpfs) to
141 be backed into memory in force, charges for pages are accounted against the
142 caller of swapoff rather than the users of shmem.
143 
144 
145 2.4 Swap Extension (CONFIG_CGROUP_MEM_RES_CTLR_SWAP)
146 Swap Extension allows you to record charge for swap. A swapped-in page is
147 charged back to original page allocator if possible.
148 
149 When swap is accounted, following files are added.
150  - memory.memsw.usage_in_bytes.
151  - memory.memsw.limit_in_bytes.
152 
153 usage of mem+swap is limited by memsw.limit_in_bytes.
154 
155 * why 'mem+swap' rather than swap.
156 The global LRU(kswapd) can swap out arbitrary pages. Swap-out means
157 to move account from memory to swap...there is no change in usage of
158 mem+swap. In other words, when we want to limit the usage of swap without
159 affecting global LRU, mem+swap limit is better than just limiting swap from
160 OS point of view.
161 
162 * What happens when a cgroup hits memory.memsw.limit_in_bytes
163 When a cgroup his memory.memsw.limit_in_bytes, it's useless to do swap-out
164 in this cgroup. Then, swap-out will not be done by cgroup routine and file
165 caches are dropped. But as mentioned above, global LRU can do swapout memory
166 from it for sanity of the system's memory management state. You can't forbid
167 it by cgroup.
168 
169 2.5 Reclaim
170 
171 Each cgroup maintains a per cgroup LRU that consists of an active
172 and inactive list. When a cgroup goes over its limit, we first try
173 to reclaim memory from the cgroup so as to make space for the new
174 pages that the cgroup has touched. If the reclaim is unsuccessful,
175 an OOM routine is invoked to select and kill the bulkiest task in the
176 cgroup.
177 
178 The reclaim algorithm has not been modified for cgroups, except that
179 pages that are selected for reclaiming come from the per cgroup LRU
180 list.
181 
182 2. Locking
183 
184 The memory controller uses the following hierarchy
185 
186 1. zone->lru_lock is used for selecting pages to be isolated
187 2. mem->per_zone->lru_lock protects the per cgroup LRU (per zone)
188 3. lock_page_cgroup() is used to protect page->page_cgroup
189 
190 3. User Interface
191 
192 0. Configuration
193 
194 a. Enable CONFIG_CGROUPS
195 b. Enable CONFIG_RESOURCE_COUNTERS
196 c. Enable CONFIG_CGROUP_MEM_RES_CTLR
197 
198 1. Prepare the cgroups
199 # mkdir -p /cgroups
200 # mount -t cgroup none /cgroups -o memory
201 
202 2. Make the new group and move bash into it
203 # mkdir /cgroups/0
204 # echo $$ >  /cgroups/0/tasks
205 
206 Since now we're in the 0 cgroup,
207 We can alter the memory limit:
208 # echo 4M > /cgroups/0/memory.limit_in_bytes
209 
210 NOTE: We can use a suffix (k, K, m, M, g or G) to indicate values in kilo,
211 mega or gigabytes.
212 NOTE: We can write "-1" to reset the *.limit_in_bytes(unlimited).
213 
214 # cat /cgroups/0/memory.limit_in_bytes
215 4194304
216 
217 NOTE: The interface has now changed to display the usage in bytes
218 instead of pages
219 
220 We can check the usage:
221 # cat /cgroups/0/memory.usage_in_bytes
222 1216512
223 
224 A successful write to this file does not guarantee a successful set of
225 this limit to the value written into the file.  This can be due to a
226 number of factors, such as rounding up to page boundaries or the total
227 availability of memory on the system.  The user is required to re-read
228 this file after a write to guarantee the value committed by the kernel.
229 
230 # echo 1 > memory.limit_in_bytes
231 # cat memory.limit_in_bytes
232 4096
233 
234 The memory.failcnt field gives the number of times that the cgroup limit was
235 exceeded.
236 
237 The memory.stat file gives accounting information. Now, the number of
238 caches, RSS and Active pages/Inactive pages are shown.
239 
240 4. Testing
241 
242 Balbir posted lmbench, AIM9, LTP and vmmstress results [10] and [11].
243 Apart from that v6 has been tested with several applications and regular
244 daily use. The controller has also been tested on the PPC64, x86_64 and
245 UML platforms.
246 
247 4.1 Troubleshooting
248 
249 Sometimes a user might find that the application under a cgroup is
250 terminated. There are several causes for this:
251 
252 1. The cgroup limit is too low (just too low to do anything useful)
253 2. The user is using anonymous memory and swap is turned off or too low
254 
255 A sync followed by echo 1 > /proc/sys/vm/drop_caches will help get rid of
256 some of the pages cached in the cgroup (page cache pages).
257 
258 4.2 Task migration
259 
260 When a task migrates from one cgroup to another, it's charge is not
261 carried forward. The pages allocated from the original cgroup still
262 remain charged to it, the charge is dropped when the page is freed or
263 reclaimed.
264 
265 4.3 Removing a cgroup
266 
267 A cgroup can be removed by rmdir, but as discussed in sections 4.1 and 4.2, a
268 cgroup might have some charge associated with it, even though all
269 tasks have migrated away from it.
270 Such charges are freed(at default) or moved to its parent. When moved,
271 both of RSS and CACHES are moved to parent.
272 If both of them are busy, rmdir() returns -EBUSY. See 5.1 Also.
273 
274 Charges recorded in swap information is not updated at removal of cgroup.
275 Recorded information is discarded and a cgroup which uses swap (swapcache)
276 will be charged as a new owner of it.
277 
278 
279 5. Misc. interfaces.
280 
281 5.1 force_empty
282   memory.force_empty interface is provided to make cgroup's memory usage empty.
283   You can use this interface only when the cgroup has no tasks.
284   When writing anything to this
285 
286   # echo 0 > memory.force_empty
287 
288   Almost all pages tracked by this memcg will be unmapped and freed. Some of
289   pages cannot be freed because it's locked or in-use. Such pages are moved
290   to parent and this cgroup will be empty. But this may return -EBUSY in
291   some too busy case.
292 
293   Typical use case of this interface is that calling this before rmdir().
294   Because rmdir() moves all pages to parent, some out-of-use page caches can be
295   moved to the parent. If you want to avoid that, force_empty will be useful.
296 
297 5.2 stat file
298 
299 memory.stat file includes following statistics
300 
301 cache           - # of bytes of page cache memory.
302 rss             - # of bytes of anonymous and swap cache memory.
303 pgpgin          - # of pages paged in (equivalent to # of charging events).
304 pgpgout         - # of pages paged out (equivalent to # of uncharging events).
305 active_anon     - # of bytes of anonymous and  swap cache memory on active
306                   lru list.
307 inactive_anon   - # of bytes of anonymous memory and swap cache memory on
308                   inactive lru list.
309 active_file     - # of bytes of file-backed memory on active lru list.
310 inactive_file   - # of bytes of file-backed memory on inactive lru list.
311 unevictable     - # of bytes of memory that cannot be reclaimed (mlocked etc).
312 
313 The following additional stats are dependent on CONFIG_DEBUG_VM.
314 
315 inactive_ratio          - VM internal parameter. (see mm/page_alloc.c)
316 recent_rotated_anon     - VM internal parameter. (see mm/vmscan.c)
317 recent_rotated_file     - VM internal parameter. (see mm/vmscan.c)
318 recent_scanned_anon     - VM internal parameter. (see mm/vmscan.c)
319 recent_scanned_file     - VM internal parameter. (see mm/vmscan.c)
320 
321 Memo:
322         recent_rotated means recent frequency of lru rotation.
323         recent_scanned means recent # of scans to lru.
324         showing for better debug please see the code for meanings.
325 
326 Note:
327         Only anonymous and swap cache memory is listed as part of 'rss' stat.
328         This should not be confused with the true 'resident set size' or the
329         amount of physical memory used by the cgroup. Per-cgroup rss
330         accounting is not done yet.
331 
332 5.3 swappiness
333   Similar to /proc/sys/vm/swappiness, but affecting a hierarchy of groups only.
334 
335   Following cgroups' swapiness can't be changed.
336   - root cgroup (uses /proc/sys/vm/swappiness).
337   - a cgroup which uses hierarchy and it has child cgroup.
338   - a cgroup which uses hierarchy and not the root of hierarchy.
339 
340 
341 6. Hierarchy support
342 
343 The memory controller supports a deep hierarchy and hierarchical accounting.
344 The hierarchy is created by creating the appropriate cgroups in the
345 cgroup filesystem. Consider for example, the following cgroup filesystem
346 hierarchy
347 
348                 root
349              /  |   \
350            /    |    \
351           a     b       c
352                         | \
353                         |  \
354                         d   e
355 
356 In the diagram above, with hierarchical accounting enabled, all memory
357 usage of e, is accounted to its ancestors up until the root (i.e, c and root),
358 that has memory.use_hierarchy enabled.  If one of the ancestors goes over its
359 limit, the reclaim algorithm reclaims from the tasks in the ancestor and the
360 children of the ancestor.
361 
362 6.1 Enabling hierarchical accounting and reclaim
363 
364 The memory controller by default disables the hierarchy feature. Support
365 can be enabled by writing 1 to memory.use_hierarchy file of the root cgroup
366 
367 # echo 1 > memory.use_hierarchy
368 
369 The feature can be disabled by
370 
371 # echo 0 > memory.use_hierarchy
372 
373 NOTE1: Enabling/disabling will fail if the cgroup already has other
374 cgroups created below it.
375 
376 NOTE2: This feature can be enabled/disabled per subtree.
377 
378 7. TODO
379 
380 1. Add support for accounting huge pages (as a separate controller)
381 2. Make per-cgroup scanner reclaim not-shared pages first
382 3. Teach controller to account for shared-pages
383 4. Start reclamation in the background when the limit is
384    not yet hit but the usage is getting closer
385 
386 Summary
387 
388 Overall, the memory controller has been a stable controller and has been
389 commented and discussed quite extensively in the community.
390 
391 References
392 
393 1. Singh, Balbir. RFC: Memory Controller, http://lwn.net/Articles/206697/
394 2. Singh, Balbir. Memory Controller (RSS Control),
395    http://lwn.net/Articles/222762/
396 3. Emelianov, Pavel. Resource controllers based on process cgroups
397    http://lkml.org/lkml/2007/3/6/198
398 4. Emelianov, Pavel. RSS controller based on process cgroups (v2)
399    http://lkml.org/lkml/2007/4/9/78
400 5. Emelianov, Pavel. RSS controller based on process cgroups (v3)
401    http://lkml.org/lkml/2007/5/30/244
402 6. Menage, Paul. Control Groups v10, http://lwn.net/Articles/236032/
403 7. Vaidyanathan, Srinivasan, Control Groups: Pagecache accounting and control
404    subsystem (v3), http://lwn.net/Articles/235534/
405 8. Singh, Balbir. RSS controller v2 test results (lmbench),
406    http://lkml.org/lkml/2007/5/17/232
407 9. Singh, Balbir. RSS controller v2 AIM9 results
408    http://lkml.org/lkml/2007/5/18/1
409 10. Singh, Balbir. Memory controller v6 test results,
410     http://lkml.org/lkml/2007/8/19/36
411 11. Singh, Balbir. Memory controller introduction (v6),
412     http://lkml.org/lkml/2007/8/17/69
413 12. Corbet, Jonathan, Controlling memory use in cgroups,
414     http://lwn.net/Articles/243795/
  This page was automatically generated by the LXR engine.