kernel: rounddown helper function
PATCH 1/1 kernel: rounddown helper function
The roundup() helper function will round a given value up to a multiple of another given value. aka roundup(11, 7) would give 14 = 7 * 2. This new function does the opposite. It will round a given number down to the nearest multiple of the second number: rounddown(11, 7) would give 7.
I need this in some future SELinux code and can carry the macro myself, but figured I would put it in the core kernel so others might find and use it if need be.
---
include/linux/kernel.h | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)
include/linux/kernel.h +1 -0
@@ -59,6 +59,7 @@ extern const char linux_proc_banner[];#define FIELD_SIZEOF (t, f) (sizeof(((t*)0)->f))#define DIV_ROUND_UP (n,d) (((n) + (d) - 1) / (d))#define roundup (x, y) ((((x) + ((y) - 1)) / (y)) * (y)) +#define rounddown (x, y) ((x) - ((x) % (y)))#define DIV_ROUND_CLOSEST (x, divisor)( \ { \ typeof(divisor) __divisor = divisor; \
--
This message was distributed to subscribers of the selinux mailing list. If you no longer wish to subscribe, send mail to [email protected] with the words "unsubscribe selinux" without quotes as the message.
Quoted 20 lines · On Tue, 03 Aug 2010 14:16:07 -0400 Eric Paris wrote:
The
roundup()helper function will round a given value up to a multiple of another given value. akaroundup(11, 7)would give 14 = 7 * 2. This new function does the opposite. It will round a given number down to the nearest multiple of the second number:rounddown(11, 7)would give 7.I need this in some future SELinux code and can carry the macro myself, but figured I would put it in the core kernel so others might find and use it if need be.
Signed-off-by Eric Paris <[email protected]>---
include/linux/kernel.h | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)include/linux/kernel.h +0
-0
include/linux/kernel.h extern const char linux_proc_banner[];
Quoted 9 lines
include/linux/kernel.h +1
-1@@ -59,6 +59,7 @@ extern const char linux_proc_banner[];#define FIELD_SIZEOF (t, f) (sizeof(((t*)0)->f))#define DIV_ROUND_UP (n,d) (((n) + (d) - 1) / (d))#define roundup (x, y) ((((x) + ((y) - 1)) / (y)) * (y)) +#define rounddown (x, y) ((x) - ((x) % (y)))#define DIV_ROUND_CLOSEST (x, divisor)( \ { \ typeof(divisor) __divisor = divisor; \ --
I'm more used to seeing it like
#define DIV_ROUND_DOWN(n, d) (((n) / (d)) * (d))
but since multiply/divide/modulus are usually slower, your (SELinux) way is better, I suppose.
and the usual caveats apply: don't use these macros with expressions (nor with y or d == 0).
---
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***
Quoted 34 lines · On Tue, 3 Aug 2010 11:23:54 -0700 Randy Dunlap <[email protected]> wrote:
Quoted 20 lines · On Tue, 03 Aug 2010 14:16:07 -0400 Eric Paris wrote:
The
roundup()helper function will round a given value up to a multiple of another given value. akaroundup(11, 7)would give 14 = 7 * 2. This new function does the opposite. It will round a given number down to the nearest multiple of the second number:rounddown(11, 7)would give 7.I need this in some future SELinux code and can carry the macro myself, but figured I would put it in the core kernel so others might find and use it if need be.
Signed-off-by Eric Paris <[email protected]>---
include/linux/kernel.h | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)include/linux/kernel.h +0
-0include/linux/kernel.h extern const char linux_proc_banner[];
Quoted 9 lines
include/linux/kernel.h +1
-1@@ -59,6 +59,7 @@ extern const char linux_proc_banner[];#define FIELD_SIZEOF (t, f) (sizeof(((t*)0)->f))#define DIV_ROUND_UP (n,d) (((n) + (d) - 1) / (d))#define roundup (x, y) ((((x) + ((y) - 1)) / (y)) * (y)) +#define rounddown (x, y) ((x) - ((x) % (y)))#define DIV_ROUND_CLOSEST (x, divisor)( \ { \ typeof(divisor) __divisor = divisor; \ --I'm more used to seeing it like
Quoted 7 lines
#define
DIV_ROUND_DOWN(n, d)(((n) / (d)) * (d))but since multiply/divide/modulus are usually slower, your (SELinux) way is better, I suppose.
and the usual caveats apply: don't use these macros with expressions (nor with y or d == 0).
Yes, it really shouldn't reference its argument twice. And that's easy to fix.
A fancy version would detect constant-power-of-two and do an `& (d - 1)' instead of the modulus. But probably the compiler does optimisatons in that case - for unsigned types, at least.
Quoted 39 lines · Andrew Morton
Quoted 36 lines · On Tue, 3 Aug 2010 11:23:54 -0700 Randy Dunlap <[email protected]> wrote:
Quoted 20 lines · On Tue, 03 Aug 2010 14:16:07 -0400 Eric Paris wrote:
The
roundup()helper function will round a given value up to a multiple of another given value. akaroundup(11, 7)would give 14 = 7 * 2. This new function does the opposite. It will round a given number down to the nearest multiple of the second number:rounddown(11, 7)would give 7.I need this in some future SELinux code and can carry the macro myself, but figured I would put it in the core kernel so others might find and use it if need be.
Signed-off-by Eric Paris <[email protected]>---
include/linux/kernel.h | 1 + 1 files changed, 1 insertions(+), 0 deletions(-)include/linux/kernel.h +0
-0include/linux/kernel.h extern const char linux_proc_banner[];
Quoted 9 lines
include/linux/kernel.h +1
-1@@ -59,6 +59,7 @@ extern const char linux_proc_banner[];#define FIELD_SIZEOF (t, f) (sizeof(((t*)0)->f))#define DIV_ROUND_UP (n,d) (((n) + (d) - 1) / (d))#define roundup (x, y) ((((x) + ((y) - 1)) / (y)) * (y)) +#define rounddown (x, y) ((x) - ((x) % (y)))#define DIV_ROUND_CLOSEST (x, divisor)( \ { \ typeof(divisor) __divisor = divisor; \ --I'm more used to seeing it like
#define
DIV_ROUND_DOWN(n, d)(((n) / (d)) * (d))
Quoted 8 lines
Quoted 5 lines
but since multiply/divide/modulus are usually slower, your (SELinux) way is better, I suppose.
and the usual caveats apply: don't use these macros with expressions (nor with y or d == 0).
Yes, it really shouldn't reference its argument twice. And that's easy to fix.
Are you suggesting something like
#define rounddown(n, d) ({ typeof(n) __n = (n); __n - (__n % (d)); })
If that's what you are hoping for, would you also like to see a patch doing the same thing for roundup() ?
Quoted 3 lines
A fancy version would detect constant-power-of-two and do an `& (d - 1)' instead of the modulus. But probably the compiler does optimisatons in that case - for unsigned types, at least.
I don't think we really need to. My quick test shows:
#define rounddown(n, d) ({typeof((n)) __n = (n); (__n - (__n % (d)));})
int round7(unsigned int a)
{
return rounddown(a, 7);
}int round4(unsigned int a)
{
return rounddown(a, 4);
}0000000000400504 <round7>:
400504: b9 07 00 00 00 mov $0x7,%ecx 400509: 89 f8 mov %edi,%eax 40050b: 31 d2 xor %edx,%edx 40050d: f7 f1 div %ecx 40050f: 89 f8 mov %edi,%eax 400511: 29 d0 sub %edx,%eax 400513: c3 retq
0000000000400514 <round4>:
400514: 89 f8 mov %edi,%eax 400516: 83 e0 fc and $0xfffffffffffffffc,%eax 400519: c3 retq
--
This message was distributed to subscribers of the selinux mailing list. If you no longer wish to subscribe, send mail to [email protected] with the words "unsubscribe selinux" without quotes as the message.
Quoted 10 lines · On Thu, 05 Aug 2010 13:56:36 -0400 Eric Paris <[email protected]> wrote:
Quoted 10 lines
Quoted 9 lines
I'm more used to seeing it like
#define
DIV_ROUND_DOWN(n, d)(((n) / (d)) * (d))but since multiply/divide/modulus are usually slower, your (SELinux) way is better, I suppose.
and the usual caveats apply: don't use these macros with expressions (nor with y or d == 0).
Quoted 6 lines
Quoted 2 lines
Yes, it really shouldn't reference its argument twice. And that's easy to fix.
Are you suggesting something like
#define
rounddown(n, d)({ typeof(n)__n= (n);__n- (__n% (d)); })
looks good.
Quoted 2 lines
If that's what you are hoping for, would you also like to see a patch doing the same thing for
roundup()?
Sure. I doubt if anything accidentally depends on the curent behavior, although that would be amusing.
Quoted 27 lines
Quoted 3 lines
A fancy version would detect constant-power-of-two and do an `& (d - 1)' instead of the modulus. But probably the compiler does optimisatons in that case - for unsigned types, at least.
I don't think we really need to. My quick test shows:
#define
rounddown(n, d)({typeof((n))__n= (n); (__n- (__n% (d)));})int round7(unsigned int a)
{ return rounddown(a, 7); }int round4(unsigned int a)
{ return rounddown(a, 4); }0000000000400504 <round7>:
400504: b9 07 00 00 00 mov $0x7,%ecx 400509: 89 f8 mov %edi,%eax 40050b: 31 d2 xor %edx,%edx 40050d: f7 f1 div %ecx 40050f: 89 f8 mov %edi,%eax 400511: 29 d0 sub %edx,%eax 400513: c3 retq
Quoted 5 lines
0000000000400514 <round4>:
400514: 89 f8 mov %edi,%eax 400516: 83 e0 fc and $0xfffffffffffffffc,%eax 400519: c3 retq
OK, thanks for checking.