1 files changed, 259 insertions, 0 deletions
diff --git a/Documentation/controllers/memory.txt b/Documentation/controllers/memory.txt
new file mode 100644
index 000000000000..7e27baacca7b
--- /dev/null
+++ b/Documentation/controllers/memory.txt
@@ -0,0 +1,259 @@
+Memory Controller
+Salient features
+a. Enable control of both RSS (mapped) and Page Cache (unmapped) pages
+b. The infrastructure allows easy addition of other types of memory to control
+c. Provides *zero overhead* for non memory controller users
+d. Provides a double LRU: global memory pressure causes reclaim from the
+   global LRU; a cgroup on hitting a limit, reclaims from the per
+   cgroup LRU
+NOTE: Page Cache (unmapped) also includes Swap Cache pages as a subset
+and will not be referred to explicitly in the rest of the documentation.
+Benefits and Purpose of the memory controller
+The memory controller isolates the memory behaviour of a group of tasks
+from the rest of the system. The article on LWN [12] mentions some probable
+uses of the memory controller. The memory controller can be used to
+a. Isolate an application or a group of applications
+   Memory hungry applications can be isolated and limited to a smaller
+   amount of memory.
+b. Create a cgroup with limited amount of memory, this can be used
+   as a good alternative to booting with mem=XXXX.
+c. Virtualization solutions can control the amount of memory they want
+   to assign to a virtual machine instance.
+d. A CD/DVD burner could control the amount of memory used by the
+   rest of the system to ensure that burning does not fail due to lack
+   of available memory.
+e. There are several other use cases, find one or use the controller just
+   for fun (to learn and hack on the VM subsystem).
+1. History
+The memory controller has a long history. A request for comments for the memory
+controller was posted by Balbir Singh [1]. At the time the RFC was posted
+there were several implementations for memory control. The goal of the
+RFC was to build consensus and agreement for the minimal features required
+for memory control. The first RSS controller was posted by Balbir Singh[2]
+in Feb 2007. Pavel Emelianov [3][4][5] has since posted three versions of the
+RSS controller. At OLS, at the resource management BoF, everyone suggested
+that we handle both page cache and RSS together. Another request was raised
+to allow user space handling of OOM. The current memory controller is
+at version 6; it combines both mapped (RSS) and unmapped Page
+Cache Control [11].
+2. Memory Control
+Memory is a unique resource in the sense that it is present in a limited
+amount. If a task requires a lot of CPU processing, the task can spread
+its processing over a period of hours, days, months or years, but with
+memory, the same physical memory needs to be reused to accomplish the task.
+The memory controller implementation has been divided into phases. These
+are:
+1. Memory controller
+2. mlock(2) controller
+3. Kernel user memory accounting and slab control
+4. user mappings length controller
+The memory controller is the first controller developed.
+2.1. Design
+The core of the design is a counter called the res_counter. The res_counter
+tracks the current memory usage and limit of the group of processes associated
+with the controller. Each cgroup has a memory controller specific data
+structure (mem_cgroup) associated with it.
+2.2. Accounting
+                +--------------------+
+                |  mem_cgroup     |
+                |  (res_counter)     |
+                +--------------------+
+                 /            ^      \
+                /             |       \
+           +---------------+  |        +---------------+
+           | mm_struct     |  |....    | mm_struct     |
+           |               |  |        |               |
+           +---------------+  |        +---------------+
+                              |
+                              + --------------+
+                                              |
+           +---------------+           +------+--------+
+           | page          +---------->  page_cgroup|
+           |               |           |               |
+           +---------------+           +---------------+
+             (Figure 1: Hierarchy of Accounting)
+Figure 1 shows the important aspects of the controller
+1. Accounting happens per cgroup
+2. Each mm_struct knows about which cgroup it belongs to
+3. Each page has a pointer to the page_cgroup, which in turn knows the
+   cgroup it belongs to
+The accounting is done as follows: mem_cgroup_charge() is invoked to setup
+the necessary data structures and check if the cgroup that is being charged
+is over its limit. If it is then reclaim is invoked on the cgroup.
+More details can be found in the reclaim section of this document.
+If everything goes well, a page meta-data-structure called page_cgroup is
+allocated and associated with the page.  This routine also adds the page to
+the per cgroup LRU.
+2.2.1 Accounting details
+All mapped pages (RSS) and unmapped user pages (Page Cache) are accounted.
+RSS pages are accounted at the time of page_add_*_rmap() unless they've already
+been accounted for earlier. A file page will be accounted for as Page Cache;
+it's mapped into the page tables of a process, duplicate accounting is carefully
+avoided. Page Cache pages are accounted at the time of add_to_page_cache().
+The corresponding routines that remove a page from the page tables or removes
+a page from Page Cache is used to decrement the accounting counters of the
+cgroup.
+2.3 Shared Page Accounting
+Shared pages are accounted on the basis of the first touch approach. The
+cgroup that first touches a page is accounted for the page. The principle
+behind this approach is that a cgroup that aggressively uses a shared
+page will eventually get charged for it (once it is uncharged from
+the cgroup that brought it in -- this will happen on memory pressure).
+2.4 Reclaim
+Each cgroup maintains a per cgroup LRU that consists of an active
+and inactive list. When a cgroup goes over its limit, we first try
+to reclaim memory from the cgroup so as to make space for the new
+pages that the cgroup has touched. If the reclaim is unsuccessful,
+an OOM routine is invoked to select and kill the bulkiest task in the
+cgroup.
+The reclaim algorithm has not been modified for cgroups, except that
+pages that are selected for reclaiming come from the per cgroup LRU
+list.
+2. Locking
+The memory controller uses the following hierarchy
+1. zone->lru_lock is used for selecting pages to be isolated
+2. mem->lru_lock protects the per cgroup LRU
+3. lock_page_cgroup() is used to protect page->page_cgroup
+3. User Interface
+0. Configuration
+a. Enable CONFIG_CGROUPS
+b. Enable CONFIG_RESOURCE_COUNTERS
+c. Enable CONFIG_CGROUP_MEM_CONT
+1. Prepare the cgroups
+# mkdir -p /cgroups
+# mount -t cgroup none /cgroups -o memory
+2. Make the new group and move bash into it
+# mkdir /cgroups/0
+# echo $$ >  /cgroups/0/tasks
+Since now we're in the 0 cgroup,
+We can alter the memory limit:
+# echo -n 6000 > /cgroups/0/memory.limit
+We can check the usage:
+# cat /cgroups/0/memory.usage
+25
+The memory.failcnt field gives the number of times that the cgroup limit was
+exceeded.
+4. Testing
+Balbir posted lmbench, AIM9, LTP and vmmstress results [10] and [11].
+Apart from that v6 has been tested with several applications and regular
+daily use. The controller has also been tested on the PPC64, x86_64 and
+UML platforms.
+4.1 Troubleshooting
+Sometimes a user might find that the application under a cgroup is
+terminated. There are several causes for this:
+1. The cgroup limit is too low (just too low to do anything useful)
+2. The user is using anonymous memory and swap is turned off or too low
+A sync followed by echo 1 > /proc/sys/vm/drop_caches will help get rid of
+some of the pages cached in the cgroup (page cache pages).
+4.2 Task migration
+When a task migrates from one cgroup to another, it's charge is not
+carried forward. The pages allocated from the original cgroup still
+remain charged to it, the charge is dropped when the page is freed or
+reclaimed.
+4.3 Removing a cgroup
+A cgroup can be removed by rmdir, but as discussed in sections 4.1 and 4.2, a
+cgroup might have some charge associated with it, even though all
+tasks have migrated away from it. If some pages are still left, after following
+the steps listed in sections 4.1 and 4.2, check the Swap Cache usage in
+/proc/meminfo to see if the Swap Cache usage is showing up in the
+cgroups memory.usage counter. A simple test of swapoff -a and swapon -a
+should free any pending Swap Cache usage.
+4.4 Choosing what to account  -- Page Cache (unmapped) vs RSS (mapped)?
+The type of memory accounted by the cgroup can be limited to just
+mapped pages by writing "1" to memory.control_type field
+echo -n 1 > memory.control_type
+5. TODO
+1. Add support for accounting huge pages (as a separate controller)
+2. Improve the user interface to accept/display memory limits in KB or MB
+   rather than pages (since page sizes can differ across platforms/machines).
+3. Make cgroup lists per-zone
+4. Make per-cgroup scanner reclaim not-shared pages first
+5. Teach controller to account for shared-pages
+6. Start reclamation when the limit is lowered
+7. Start reclamation in the background when the limit is
+   not yet hit but the usage is getting closer
+8. Create per zone LRU lists per cgroup
+Summary
+Overall, the memory controller has been a stable controller and has been
+commented and discussed quite extensively in the community.
+References
+1. Singh, Balbir. RFC: Memory Controller, http://lwn.net/Articles/206697/
+2. Singh, Balbir. Memory Controller (RSS Control),
+   http://lwn.net/Articles/222762/
+3. Emelianov, Pavel. Resource controllers based on process cgroups
+   http://lkml.org/lkml/2007/3/6/198
+4. Emelianov, Pavel. RSS controller based on process cgroups (v2)
+   http://lkml.org/lkml/2007/4/9/74
+5. Emelianov, Pavel. RSS controller based on process cgroups (v3)
+   http://lkml.org/lkml/2007/5/30/244
+6. Menage, Paul. Control Groups v10, http://lwn.net/Articles/236032/
+7. Vaidyanathan, Srinivasan, Control Groups: Pagecache accounting and control
+   subsystem (v3), http://lwn.net/Articles/235534/
+8. Singh, Balbir. RSS controller V2 test results (lmbench),
+   http://lkml.org/lkml/2007/5/17/232
+9. Singh, Balbir. RSS controller V2 AIM9 results
+   http://lkml.org/lkml/2007/5/18/1
+10. Singh, Balbir. Memory controller v6 results,
+    http://lkml.org/lkml/2007/8/19/36
+11. Singh, Balbir. Memory controller v6, http://lkml.org/lkml/2007/8/17/69
+12. Corbet, Jonathan, Controlling memory use in cgroups,
+    http://lwn.net/Articles/243795/

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