* [PATCH] kernel: rounddown helper function
@ 2010-08-03 18:16 Eric Paris
2010-08-03 18:23 ` Randy Dunlap
0 siblings, 1 reply; 5+ messages in thread
From: Eric Paris @ 2010-08-03 18:16 UTC (permalink / raw)
To: linux-kernel, selinux; +Cc: akpm, sds, jmorris
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.
Signed-off-by: Eric Paris <eparis@redhat.com>
---
include/linux/kernel.h | 1 +
1 files changed, 1 insertions(+), 0 deletions(-)
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7d5b10f..d6092fd 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -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; \
^ permalink raw reply related [flat|nested] 5+ messages in thread
* Re: [PATCH] kernel: rounddown helper function
2010-08-03 18:16 [PATCH] kernel: rounddown helper function Eric Paris
@ 2010-08-03 18:23 ` Randy Dunlap
2010-08-04 21:35 ` Andrew Morton
0 siblings, 1 reply; 5+ messages in thread
From: Randy Dunlap @ 2010-08-03 18:23 UTC (permalink / raw)
To: Eric Paris; +Cc: linux-kernel, selinux, akpm, sds, jmorris
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. 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.
>
> Signed-off-by: Eric Paris <eparis@redhat.com>
> ---
>
> include/linux/kernel.h | 1 +
> 1 files changed, 1 insertions(+), 0 deletions(-)
>
> diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> index 7d5b10f..d6092fd 100644
> --- a/include/linux/kernel.h
> +++ b/include/linux/kernel.h
> @@ -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 ***
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] kernel: rounddown helper function
2010-08-03 18:23 ` Randy Dunlap
@ 2010-08-04 21:35 ` Andrew Morton
2010-08-05 17:56 ` Eric Paris
0 siblings, 1 reply; 5+ messages in thread
From: Andrew Morton @ 2010-08-04 21:35 UTC (permalink / raw)
To: Randy Dunlap; +Cc: Eric Paris, linux-kernel, selinux, sds, jmorris
On Tue, 3 Aug 2010 11:23:54 -0700
Randy Dunlap <randy.dunlap@oracle.com> wrote:
> 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. 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.
> >
> > Signed-off-by: Eric Paris <eparis@redhat.com>
> > ---
> >
> > include/linux/kernel.h | 1 +
> > 1 files changed, 1 insertions(+), 0 deletions(-)
> >
> > diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> > index 7d5b10f..d6092fd 100644
> > --- a/include/linux/kernel.h
> > +++ b/include/linux/kernel.h
> > @@ -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).
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.
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] kernel: rounddown helper function
2010-08-04 21:35 ` Andrew Morton
@ 2010-08-05 17:56 ` Eric Paris
2010-08-05 19:03 ` Andrew Morton
0 siblings, 1 reply; 5+ messages in thread
From: Eric Paris @ 2010-08-05 17:56 UTC (permalink / raw)
To: Andrew Morton; +Cc: Randy Dunlap, linux-kernel, selinux, sds, jmorris
On Wed, 2010-08-04 at 14:35 -0700, Andrew Morton wrote:
> On Tue, 3 Aug 2010 11:23:54 -0700
> Randy Dunlap <randy.dunlap@oracle.com> wrote:
>
> > 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. 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.
> > >
> > > Signed-off-by: Eric Paris <eparis@redhat.com>
> > > ---
> > >
> > > include/linux/kernel.h | 1 +
> > > 1 files changed, 1 insertions(+), 0 deletions(-)
> > >
> > > diff --git a/include/linux/kernel.h b/include/linux/kernel.h
> > > index 7d5b10f..d6092fd 100644
> > > --- a/include/linux/kernel.h
> > > +++ b/include/linux/kernel.h
> > > @@ -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).
>
> 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() ?
> 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
^ permalink raw reply [flat|nested] 5+ messages in thread
* Re: [PATCH] kernel: rounddown helper function
2010-08-05 17:56 ` Eric Paris
@ 2010-08-05 19:03 ` Andrew Morton
0 siblings, 0 replies; 5+ messages in thread
From: Andrew Morton @ 2010-08-05 19:03 UTC (permalink / raw)
To: Eric Paris; +Cc: Randy Dunlap, linux-kernel, selinux, sds, jmorris
On Thu, 05 Aug 2010 13:56:36 -0400
Eric Paris <eparis@redhat.com> wrote:
> > > 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).
> >
> > 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.
> 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.
> > 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
>
OK, thanks for checking.
^ permalink raw reply [flat|nested] 5+ messages in thread
end of thread, other threads:[~2010-08-05 19:04 UTC | newest]
Thread overview: 5+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2010-08-03 18:16 [PATCH] kernel: rounddown helper function Eric Paris
2010-08-03 18:23 ` Randy Dunlap
2010-08-04 21:35 ` Andrew Morton
2010-08-05 17:56 ` Eric Paris
2010-08-05 19:03 ` Andrew Morton
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).