Documentation/controllers/memory.txt

   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 anon pages (RSS) and cache pages (Page Cache) are accounted.
 116 (some pages which never be reclaimable and will not be on global LRU
 117  are not accounted. we just accounts pages under usual vm management.)
 118
 119 RSS pages are accounted at page_fault unless they've already been accounted
 120 for earlier. A file page will be accounted for as Page Cache when it's
 121 inserted into inode (radix-tree). While it's mapped into the page tables of
 122 processes, duplicate accounting is carefully avoided.
 123
 124 A RSS page is unaccounted when it's fully unmapped. A PageCache page is
 125 unaccounted when it's removed from radix-tree.
 126
 127 At page migration, accounting information is kept.
 128
 129 Note: we just account pages-on-lru because our purpose is to control amount
 130 of used pages. not-on-lru pages are tend to be out-of-control from vm view.
 131
 132 2.3 Shared Page Accounting
 133
 134 Shared pages are accounted on the basis of the first touch approach. The
 135 cgroup that first touches a page is accounted for the page. The principle
 136 behind this approach is that a cgroup that aggressively uses a shared
 137 page will eventually get charged for it (once it is uncharged from
 138 the cgroup that brought it in -- this will happen on memory pressure).
 139
 140 2.4 Reclaim
 141
 142 Each cgroup maintains a per cgroup LRU that consists of an active
 143 and inactive list. When a cgroup goes over its limit, we first try
 144 to reclaim memory from the cgroup so as to make space for the new
 145 pages that the cgroup has touched. If the reclaim is unsuccessful,
 146 an OOM routine is invoked to select and kill the bulkiest task in the
 147 cgroup.
 148
 149 The reclaim algorithm has not been modified for cgroups, except that
 150 pages that are selected for reclaiming come from the per cgroup LRU
 151 list.
 152
 153 2. Locking
 154
 155 The memory controller uses the following hierarchy
 156
 157 1. zone->lru_lock is used for selecting pages to be isolated
 158 2. mem->per_zone->lru_lock protects the per cgroup LRU (per zone)
 159 3. lock_page_cgroup() is used to protect page->page_cgroup
 160
 161 3. User Interface
 162
 163 0. Configuration
 164
 165 a. Enable CONFIG_CGROUPS
 166 b. Enable CONFIG_RESOURCE_COUNTERS
 167 c. Enable CONFIG_CGROUP_MEM_RES_CTLR
 168
 169 1. Prepare the cgroups
 170 # mkdir -p /cgroups
 171 # mount -t cgroup none /cgroups -o memory
 172
 173 2. Make the new group and move bash into it
 174 # mkdir /cgroups/0
 175 # echo $$ >  /cgroups/0/tasks
 176
 177 Since now we're in the 0 cgroup,
 178 We can alter the memory limit:
 179 # echo 4M > /cgroups/0/memory.limit_in_bytes
 180
 181 NOTE: We can use a suffix (k, K, m, M, g or G) to indicate values in kilo,
 182 mega or gigabytes.
 183
 184 # cat /cgroups/0/memory.limit_in_bytes
 185 4194304
 186
 187 NOTE: The interface has now changed to display the usage in bytes
 188 instead of pages
 189
 190 We can check the usage:
 191 # cat /cgroups/0/memory.usage_in_bytes
 192 1216512
 193
 194 A successful write to this file does not guarantee a successful set of
 195 this limit to the value written into the file.  This can be due to a
 196 number of factors, such as rounding up to page boundaries or the total
 197 availability of memory on the system.  The user is required to re-read
 198 this file after a write to guarantee the value committed by the kernel.
 199
 200 # echo 1 > memory.limit_in_bytes
 201 # cat memory.limit_in_bytes
 202 4096
 203
 204 The memory.failcnt field gives the number of times that the cgroup limit was
 205 exceeded.
 206
 207 The memory.stat file gives accounting information. Now, the number of
 208 caches, RSS and Active pages/Inactive pages are shown.
 209
 210 The memory.force_empty gives an interface to drop *all* charges by force.
 211
 212 # echo 1 > memory.force_empty
 213
 214 will drop all charges in cgroup. Currently, this is maintained for test.
 215
 216 4. Testing
 217
 218 Balbir posted lmbench, AIM9, LTP and vmmstress results [10] and [11].
 219 Apart from that v6 has been tested with several applications and regular
 220 daily use. The controller has also been tested on the PPC64, x86_64 and
 221 UML platforms.
 222
 223 4.1 Troubleshooting
 224
 225 Sometimes a user might find that the application under a cgroup is
 226 terminated. There are several causes for this:
 227
 228 1. The cgroup limit is too low (just too low to do anything useful)
 229 2. The user is using anonymous memory and swap is turned off or too low
 230
 231 A sync followed by echo 1 > /proc/sys/vm/drop_caches will help get rid of
 232 some of the pages cached in the cgroup (page cache pages).
 233
 234 4.2 Task migration
 235
 236 When a task migrates from one cgroup to another, it's charge is not
 237 carried forward. The pages allocated from the original cgroup still
 238 remain charged to it, the charge is dropped when the page is freed or
 239 reclaimed.
 240
 241 4.3 Removing a cgroup
 242
 243 A cgroup can be removed by rmdir, but as discussed in sections 4.1 and 4.2, a
 244 cgroup might have some charge associated with it, even though all
 245 tasks have migrated away from it. Such charges are automatically dropped at
 246 rmdir() if there are no tasks.
 247
 248 5. TODO
 249
 250 1. Add support for accounting huge pages (as a separate controller)
 251 2. Make per-cgroup scanner reclaim not-shared pages first
 252 3. Teach controller to account for shared-pages
 253 4. Start reclamation in the background when the limit is
 254    not yet hit but the usage is getting closer
 255
 256 Summary
 257
 258 Overall, the memory controller has been a stable controller and has been
 259 commented and discussed quite extensively in the community.
 260
 261 References
 262
 263 1. Singh, Balbir. RFC: Memory Controller, http://lwn.net/Articles/206697/
 264 2. Singh, Balbir. Memory Controller (RSS Control),
 265    http://lwn.net/Articles/222762/
 266 3. Emelianov, Pavel. Resource controllers based on process cgroups
 267    http://lkml.org/lkml/2007/3/6/198
 268 4. Emelianov, Pavel. RSS controller based on process cgroups (v2)
 269    http://lkml.org/lkml/2007/4/9/78
 270 5. Emelianov, Pavel. RSS controller based on process cgroups (v3)
 271    http://lkml.org/lkml/2007/5/30/244
 272 6. Menage, Paul. Control Groups v10, http://lwn.net/Articles/236032/
 273 7. Vaidyanathan, Srinivasan, Control Groups: Pagecache accounting and control
 274    subsystem (v3), http://lwn.net/Articles/235534/
 275 8. Singh, Balbir. RSS controller v2 test results (lmbench),
 276    http://lkml.org/lkml/2007/5/17/232
 277 9. Singh, Balbir. RSS controller v2 AIM9 results
 278    http://lkml.org/lkml/2007/5/18/1
 279 10. Singh, Balbir. Memory controller v6 test results,
 280     http://lkml.org/lkml/2007/8/19/36
 281 11. Singh, Balbir. Memory controller introduction (v6),
 282     http://lkml.org/lkml/2007/8/17/69
 283 12. Corbet, Jonathan, Controlling memory use in cgroups,
 284     http://lwn.net/Articles/243795/