Make RSS accounting display more user friendly
PATCH 1/1 Make RSS accounting display more user friendly
Display the current usage and limit in a more user friendly manner. Number of pages can be confusing if the page size is different. Some systems can choose a page size of 64KB.
NOTE: Values shown in MB and GB could be rounded off.
Sample display
:~ # cat /container/rss_limit
17179869183 (GB), 9223372036854775807 pages
:~ # cat /container/rss_usage
36 (MB), 9220 pages
:~ #
---
include/linux/res_counter.h | 6 ++++++ kernel/res_counter.c | 27 +++++++++++++++++++++++---- 2 files changed, 29 insertions(+), 4 deletions(-)
kernel/res_counter.c renamed from kernel/res_counter.c~rss-ui-display-kdb +23 -4
@@ -61,7 +61,8 @@ void res_counter_uncharge(struct res_cou } -static inline unsigned long *res_counter_member (struct res_counter *cnt,int member) +static inline unsigned long *res_counter_member (struct res_counter *cnt, +int member,int *format_mem) {switch (member) {case RES_USAGE :
@@ -69,6 +70,7 @@ static inline unsigned long *res_countercase RES_LIMIT :return &cnt->limit;case RES_FAILCNT : + *format_mem =0 ;return &cnt->failcnt; };
@@ -81,10 +83,26 @@ ssize_t res_counter_read(struct res_coun {unsigned long *val;char buf[64 ], *s; +int format_mem =1 ; +unsigned long val_kb =0 , val_mb =0 , val_gb =0 ; s = buf; - val =res_counter_member (cnt, member); - s +=sprintf (s,"%lu\n" , *val); + val =res_counter_member (cnt, member, &format_mem); +/* +* NOTE: GB and MB values might be rounded off +*/ +if (format_mem) { + val_gb = (*val <<PAGE_SHIFT ) >>GB_SHIFT ; + val_mb = (*val <<PAGE_SHIFT ) >>MB_SHIFT ; + val_kb = (*val <<PAGE_SHIFT ) >>KB_SHIFT ; +if (val_gb) + s +=sprintf (s,"%lu (GB), %lu pages\n" , val_gb, *val); +else if (val_mb) + s +=sprintf (s,"%lu (MB), %lu pages\n" , val_mb, *val); +else + s +=sprintf (s,"%lu (KB), %lu pages\n" , val_kb, *val); + }else + s +=sprintf (s,"%lu\n" , *val);return simple_read_from_buffer ((void __user *)userbuf, nbytes, pos, buf, s - buf); }
@@ -95,6 +113,7 @@ ssize_t res_counter_write(struct res_couint ret;char *buf, *end;unsigned long tmp, *val; +int nop; buf =kmalloc (nbytes +1 ,GFP_KERNEL ); ret = -ENOMEM ;
@@ -111,7 +130,7 @@ ssize_t res_counter_write(struct res_couif (*end !='\0' ) goto out_free; - val =res_counter_member (cnt, member); + val =res_counter_member (cnt, member, &nop); *val = tmp; ret = nbytes; out_free:
include/linux/res_counter.h renamed from include/linux/res_counter.h~rss-ui-display-kdb +6 -0
@@ -13,6 +13,12 @@#include <linux/container.h> +#ifndef KB_SHIFT +#define KB_SHIFT 10 +#define MB_SHIFT 20 +#define GB_SHIFT 30 +#endif +/* * the core object. the container that wishes to account for some * resource may include this counter into its structures and use
_
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 5 lines · Balbir Singh
Display the current usage and limit in a more user friendly manner. Number of pages can be confusing if the page size is different. Some systems can choose a page size of 64KB.
I'm not sure that's such a great idea. "Human-friendly" representations would make programmatic parsing harder.
What's wrong with just showing counts in bytes in the control files?
Paul
Quoted 8 lines · Paul Menage
Quoted 6 lines · Balbir Singh
Display the current usage and limit in a more user friendly manner. Number
of pages can be confusing if the page size is different. Some systems can choose a page size of 64KB.
Quoted 4 lines
I'm not sure that's such a great idea. "Human-friendly" representations would make programmatic parsing harder.
What's wrong with just showing counts in bytes in the control files?
Nothing wrong, but currently they are shown in "natural" points, i.e. in those that the controller accounts them in. For RSS controller the natural point is "page", but auto-converting them from pages to bytes is wrong, as not all the controllers account in pages. I think that the better way is to show the value in the internal units and specify (somehow) what these units are. The userspace then can read them and convert accordingly.
Quoted 1 line
Paul
Thanks,
Pavel
Quoted 5 lines · Pavel Emelianov
Nothing wrong, but currently they are shown in "natural" points, i.e. in those that the controller accounts them in. For RSS controller the natural point is "page", but auto-converting them from pages to bytes is wrong, as not all the controllers account in pages.
This exposes more implementation detail than I think is good. Something like a memory controller should use a more abstract interface like bytes, and do the conversion to/from its internal "natural" units like pages internally. E.g. the example cpu accounting controller that I included with my patch set reports usage in milliseconds, even though it counts internally in jiffies.
Paul
Quoted 7 lines · Paul Menage
Quoted 5 lines · Pavel Emelianov
Nothing wrong, but currently they are shown in "natural" points, i.e. in those that the controller accounts them in. For RSS controller the natural point is "page", but auto-converting them from pages to bytes is wrong, as not all the controllers account in pages.
Quoted 7 lines
This exposes more implementation detail than I think is good. Something like a memory controller should use a more abstract interface like bytes, and do the conversion to/from its internal "natural" units like pages internally. E.g. the example cpu accounting controller that I included with my patch set reports usage in milliseconds, even though it counts internally in jiffies.
Hi, Paul,
Bytes are too fine grained. Do we also accept the input in bytes? kB are probably the best, but then with the limit set to LONG_MAX, kB wrap around (if the input is in units of pages) on 64 bit machines (the sameapplies to bytes as well).
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.
Quoted 6 lines · Balbir Singh
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.
Having input in bytes seems pretty natural to me. Why not just have the RSS controller round the input to the nearest page (or whatever granularity of memory the controller is able to limit at)?
Paul
Quoted 8 lines · Paul Menage
Quoted 6 lines · Balbir Singh
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.
Quoted 5 lines
Having input in bytes seems pretty natural to me. Why not just have the RSS controller round the input to the nearest page (or whatever granularity of memory the controller is able to limit at)?
Paul
Hi, Paul,
I am not a CLUI expert, but rounding off bytes will something that the administrators will probably complain about. Since we manage the controller memory in pages, it might be the easiest unit to use. The output is totally different matter.
Having said that, I am not opposed to your suggestion, I'll see if I can find good CLUI guidelines.
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 7 lines · Balbir Singh
I am not a CLUI expert, but rounding off bytes will something that the administrators will probably complain about. Since we manage the controller memory in pages, it might be the easiest unit to use. The output is totally different matter.
Having said that, I am not opposed to your suggestion, I'll see if I can find good CLUI guidelines.
Pages are generally considered a bad unit for user-space exposed parameters because a page can have a wide spectrum of sizes on some machines.
The typical unit used in its stead is KiB. Although I could imagine MiB being more useful in this case :-)
Perhaps a new proc parser that takes postfix [KMG] units would be handy..
Quoted 7 lines · Peter Zijlstra
Quoted 5 lines · Balbir Singh
I am not a CLUI expert, but rounding off bytes will something that the administrators will probably complain about. Since we manage the controller memory in pages, it might be the easiest unit to use. The output is totally different matter.
Quoted 7 lines
Quoted 2 lines
Having said that, I am not opposed to your suggestion, I'll see if I can find good CLUI guidelines.
Pages are generally considered a bad unit for user-space exposed parameters because a page can have a wide spectrum of sizes on some machines.
Exactly!
Quoted 3 lines
The typical unit used in its stead is KiB. Although I could imagine MiB being more useful in this case :-)
I think a routine that can handle either KiB or MiB would probably be the best
Quoted 3 lines
Perhaps a new proc parser that takes postfix [KMG] units would be handy..
Hmm.. yes.. a library routine would be nice!
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 22 lines · On Mon, 09 Jul 2007 21:44:31 -0700 Balbir Singh wrote:
Quoted 7 lines · Peter Zijlstra
Quoted 5 lines · Balbir Singh
I am not a CLUI expert, but rounding off bytes will something that the administrators will probably complain about. Since we manage the controller memory in pages, it might be the easiest unit to use. The output is totally different matter.
Quoted 7 lines
Quoted 2 lines
Having said that, I am not opposed to your suggestion, I'll see if I can find good CLUI guidelines.
Pages are generally considered a bad unit for user-space exposed parameters because a page can have a wide spectrum of sizes on some machines.
Exactly!
Quoted 3 lines
The typical unit used in its stead is KiB. Although I could imagine MiB being more useful in this case :-)
Quoted 7 lines
I think a routine that can handle either KiB or MiB would probably be the best
Quoted 3 lines
Perhaps a new proc parser that takes postfix [KMG] units would be handy..
Hmm.. yes.. a library routine would be nice!
you mean something like lib/cmdline.c::memparse() ?
---
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***
Quoted 4 lines · Randy Dunlap
Quoted 1 line
Hmm.. yes.. a library routine would be nice!
you mean something like lib/cmdline.c::memparse() ?
Excellent, one of the reasons to love Linux (there's already code) :-)
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 9 lines · Paul Menage
Quoted 5 lines · Balbir Singh
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.
Quoted 3 lines
Having input in bytes seems pretty natural to me. Why not just have the RSS controller round the input to the nearest page (or whatever granularity of memory the controller is able to limit at)?
totally agree with Paul.
Kirill
Quoted 9 lines · Kirill Korotaev
Quoted 8 lines · Paul Menage
Quoted 5 lines · Balbir Singh
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.
Quoted 8 lines
Quoted 3 lines
Having input in bytes seems pretty natural to me. Why not just have the RSS controller round the input to the nearest page (or whatever granularity of memory the controller is able to limit at)?
totally agree with Paul.
Kirill
Kirill
If someone assigns a rss_limit of 1 byte and sees a usage of 1 page, won't that be confusing. But having said that it's not a big change, it should be easy to accommodate.
Signature · 4 lines
Warm Regards, Balbir Singh Linux Technology Center IBM, ISTL
Quoted 19 lines · Balbir Singh
Quoted 17 lines · Kirill Korotaev
Quoted 9 lines · Paul Menage
Quoted 5 lines · Balbir Singh
The problem with input in bytes is that the user will have to ensure that the input is
a multiple of page size, which implies that she would need to use the calculator every time.Quoted 3 lines
Having input in bytes seems pretty natural to me. Why not just have the RSS controller round the input to the nearest page (or whatever granularity of memory the controller is able to limit at)?
totally agree with Paul.
Quoted 8 lines
Quoted 2 lines
Kirill
Kirill
If someone assigns a
rss_limitof 1 byte and sees a usage of 1 page, won't that be confusing. But having said that it's not a big change, it should be easy to accommodate.
Well, from my expirience pages are hardly understandable by people. So bytes are always better and more convinient for non-programmers. Rounding is not that big issue, since people still get the result they expect (unlike to the case when they mess up with the page size).
Thanks,
Kirill
P.S. 1 byte limit is not that common :)