Skip to contentSkip to conversation

kernel: rounddown helper function

PATCH In review Eric Paris 3 participants 5 messages Aug 3, 2010 – Aug 5, 2010 SELinux security module

lore
Share & tools
lore

Eric Paris

author
#0 lore raw

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
index 7d5b10f..d6092fd 100644
@@ -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.

#1 lore raw
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. 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 +0 -0
index 7d5b10f..d6092fd 100644

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 ***

#2 lore raw
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. 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 +0 -0
index 7d5b10f..d6092fd 100644

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

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.

author
#3 lore raw
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. 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 +0 -0
index 7d5b10f..d6092fd 100644

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))

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.

#4 lore raw
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.