On-demand accounting - Revision history

Kir: kernel internals

2008-01-24T12:55:12Z

kernel internals

Kir: /* Example */ use source tag

2007-12-25T08:57:03Z

‎Example: use source tag

Kir: /* Current accounting model */ use source tag

2007-12-25T08:56:19Z

‎Current accounting model: use source tag

Xemul: Added `around function`


2007-07-05T12:34:55Z
Added <code> around function

				
				
				
				
				
				← Older revision
				Revision as of 12:34, 5 July 2007
				
Line 33:
Line 33:
  The <code>charge_beancounter()</code> call is responsible for checking whether the user is allowed to get the requested amount of the resource, i.e. if the resource consumption level is lower than the limit set.   The <code>charge_beancounter()</code> call is responsible for checking whether the user is allowed to get the requested amount of the resource, i.e. if the resource consumption level is lower than the limit set.
    
− Obviously, this change slows down the original code, as charge_beancounter() takes some slow operations like taking locks. We have an idea of how to optimize this behavior. + Obviously, this change slows down the original code, as <code>charge_beancounter()</code> takes some slow operations like taking locks. We have an idea of how to optimize this behavior.
    
  == On-demand accounting basics ==   == On-demand accounting basics ==



Kir: spelling /* Example */
2007-07-05T12:34:45Z
spelling ‎Example

				
				
				
				
				
				← Older revision
				Revision as of 12:34, 5 July 2007
				
Line 61:
Line 61:
  </pre>   </pre>
    
− However, we have a good upper estimation of the RSS size — that is the lengths of mappings of the processes. Since the physical pages can only be allocated within these mappings, the RSS value can never exceed the sum of their lenghs. The accounting will then look like this: + However, we have a good upper estimation of the RSS size — that is the lengths of mappings of the processes. Since the physical pages can only be allocated within these mappings, the RSS value can never exceed the sum of their lengths. The accounting will then look like this:
  <pre>   <pre>
  struct vm_area_struct *get_new_mapping(struct mm_struct *mm,   struct vm_area_struct *get_new_mapping(struct mm_struct *mm,



Kir: spelling/wording fixes /* Example */
2007-07-05T12:33:48Z
spelling/wording fixes ‎Example

				
				
				
				
				
				← Older revision
				Revision as of 12:33, 5 July 2007
				
Line 43:
Line 43:
  Let's look at example of how this will work with the user memory accounting.   Let's look at example of how this will work with the user memory accounting.
    
− Currently we account for the [[physpages]] resource. That is -- the number of physical pages consumed by the processes. The accounting hooks are placed inside the page faults and hurt the performance. The accounting looks like this: + Currently we account for the [[physpages]] resource, that is, the number of physical pages consumed by a set of processes. The accounting hooks are placed inside the page fault handlers and thus hurting the performance. Currently accounting looks like this:
  <pre>   <pre>
  struct page *get_new_page(struct mm_struct *mm)   struct page *get_new_page(struct mm_struct *mm)
Line 61:
Line 61:
  </pre>   </pre>
    
− However, we have a good estimation of the RSS size -- that is the lenghts of mappings of the processes. Since the physical pages can only be allocated within these mappgins the RSS value can never exceed the sum of theis lenghs. The accounting will then look like this: + However, we have a good upper estimation of the RSS size — that is the lengths of mappings of the processes. Since the physical pages can only be allocated within these mappings, the RSS value can never exceed the sum of their lenghs. The accounting will then look like this:
  <pre>   <pre>
  struct vm_area_struct *get_new_mapping(struct mm_struct *mm,   struct vm_area_struct *get_new_mapping(struct mm_struct *mm,
Line 97:
Line 97:
  }   }
  </pre>   </pre>
− We do not call the slow <code>charge_beancounter()</code> function in the page fault (<code>get_new_page()</code>). Instead we account for the upper estimation in <code>get_new_mapping()</code> call that happens rarely and thus increase the performance. + We do not call the slow <code>charge_beancounter()</code> function in the page fault (<code>get_new_page()</code>). Instead we account for the upper estimation in <code>get_new_mapping()</code> call that happens rarely and thus do not affect the performance.
    
  Note, that the <code>recalculate_the_rss()</code> is called to calculate the exact RSS value on the beancounter.   Note, that the <code>recalculate_the_rss()</code> is called to calculate the exact RSS value on the beancounter.



Kir: a bunch of spelling fixes /* On-demand accounting basics */
2007-07-05T12:27:10Z
a bunch of spelling fixes ‎On-demand accounting basics

				
				
				
				
				
				← Older revision
				Revision as of 12:27, 5 July 2007
				
Line 37:
Line 37:
  == On-demand accounting basics ==   == On-demand accounting basics ==
  The main idea sonds like this:   The main idea sonds like this:
− {{out|If the cunsumption level of any resource can be easily upper estimated with some value, and this setimation is lower than the limit, then we do not need to know the exact consumption level and allow the resource allocation without additional checks}} + {{out|If the consumption level of any resource can be easily upper estimated with some value, and this estimation is lower than the limit, then we do not need to know the exact consumption level and allow the resource allocation without additional checks}}
− Apparently, when the estimation exceeds the limit, we must switch to the slower mode, that will give us more presice value of the consumption level and (probably) allocate another portion of the resource. + Apparently, when the estimation exceeds the limit, we must switch to the slower mode, that will give us more precise value of the consumption level and (probably) allocate another portion of the resource.
    
  == Example ==   == Example ==



Kir: /* Current accounting model */ wording
2007-07-05T12:25:54Z
‎Current accounting model:  wording

				
				
				
				
				
				← Older revision
				Revision as of 12:25, 5 July 2007
				
Line 31:
Line 31:
  }   }
  </pre>   </pre>
− The <code>charge_beancounter()</code> call is responsible for checking whether the user is allowed to consume desired amount of the resource, i.e. if the resource consumption level is lower than the limit set. + The <code>charge_beancounter()</code> call is responsible for checking whether the user is allowed to get the requested amount of the resource, i.e. if the resource consumption level is lower than the limit set.
    
  Obviously, this change slows down the original code, as charge_beancounter() takes some slow operations like taking locks. We have an idea of how to optimize this behavior.   Obviously, this change slows down the original code, as charge_beancounter() takes some slow operations like taking locks. We have an idea of how to optimize this behavior.



Kir: spelling fix
2007-07-05T12:24:00Z
spelling fix

				
				
				
				
				
				← Older revision
				Revision as of 12:24, 5 July 2007
				
Line 1:
Line 1:
  {{UBC toc}}   {{UBC toc}}
    
− This page describes a very promising way of beancounters optimisation. + This page describes a very promising way of beancounters optimization.
    
  == Current accounting model ==   == Current accounting model ==



Xemul: Added future plans and fixed the examples
2007-07-05T12:03:39Z
Added future plans and fixed the examples

				
				
				
				
				
				← Older revision
				Revision as of 12:03, 5 July 2007
				
Line 40:
Line 40:
  Apparently, when the estimation exceeds the limit, we must switch to the slower mode, that will give us more presice value of the consumption level and (probably) allocate another portion of the resource.   Apparently, when the estimation exceeds the limit, we must switch to the slower mode, that will give us more presice value of the consumption level and (probably) allocate another portion of the resource.
    
− == Examples == + == Example ==
− Let's look at some examples of how this will work. + Let's look at example of how this will work with the user memory accounting.
− === The user memory === +  
  Currently we account for the [[physpages]] resource. That is -- the number of physical pages consumed by the processes. The accounting hooks are placed inside the page faults and hurt the performance. The accounting looks like this:   Currently we account for the [[physpages]] resource. That is -- the number of physical pages consumed by the processes. The accounting hooks are placed inside the page faults and hurt the performance. The accounting looks like this:
  <pre>   <pre>
Line 100:
Line 100:
    
  Note, that the <code>recalculate_the_rss()</code> is called to calculate the exact RSS value on the beancounter.   Note, that the <code>recalculate_the_rss()</code> is called to calculate the exact RSS value on the beancounter.
  + 
  + == More things to do ==
  + In this model we switch from the fast acounting to the slow one. However, if the upper estimation becomes lower than the limit again we can switch back to the fast model. However, these switches are not very fast themselves, and being too frequent can hurt the performance instead of improving. So this would require some further investigations.

@@ Line 44: / Line 44: @@
 Currently we account for the [[physpages]] resource, that is, the number of physical pages consumed by a set of processes. The accounting hooks are placed inside the page fault handlers and thus hurting the performance. Currently accounting looks like this:
-<pre>
+<source lang="c">
 struct page *get_new_page(struct mm_struct *mm)
+{
@@ Line 59: / Line 59: @@
          return NULL;
+}
-</pre>
+</source>
 However, we have a good upper estimation of the RSS size — that is the lengths of mappings of the processes. Since the physical pages can only be allocated within these mappings, the RSS value can never exceed the sum of their lengths. The accounting will then look like this:
-<pre>
+<source lang="c">
 struct vm_area_struct *get_new_mapping(struct mm_struct *mm,
                  unsigned long pages)
@@ Line 96: / Line 96: @@
          return NULL;
+}
-</pre>
+</source>
 We do not call the slow <code>charge_beancounter()</code> function in the page fault (<code>get_new_page()</code>). Instead we account for the upper estimation in <code>get_new_mapping()</code> call that happens rarely and thus do not affect the performance.

@@ Line 5: / Line 5: @@
 == Current accounting model ==
 Basically allocation of any kind of resource looks like this:
-<pre>
+<source lang="c">
 struct some_resource *get_the_resource(int amount)
+{
@@ Line 13: / Line 13: @@
          return ret;
+}
-</pre>
+</source>
 We change this behaviour to work like this:
-<pre>
+<source lang="c">
 struct some_resource *get_the_resource(int amount)
+{
@@ Line 30: / Line 30: @@
          return NULL;
+}
-</pre>
+</source>
 The <code>charge_beancounter()</code> call is responsible for checking whether the user is allowed to get the requested amount of the resource, i.e. if the resource consumption level is lower than the limit set.

← Older revision		Revision as of 12:55, 24 January 2008
Line 1:		Line 1:
	{{UBC toc}}		{{UBC toc}}
		+	[[Category: Kernel internals]]

	This page describes a very promising way of beancounters optimization.		This page describes a very promising way of beancounters optimization.

On-demand accounting - Revision history

Kir: kernel internals

Kir: /* Example */ use source tag

Kir: /* Current accounting model */ use source tag

Xemul: Added around function

Kir: spelling /* Example */

Kir: spelling/wording fixes /* Example */

Kir: a bunch of spelling fixes /* On-demand accounting basics */

Kir: /* Current accounting model */ wording

Kir: spelling fix

Xemul: Added future plans and fixed the examples

Xemul: Added `around function`