[PATCH 1/2] time: refactor usecs_to_jiffies

[PATCH 1/2] time: refactor usecs_to_jiffies

[Nicholas Mc Guire]

Refactor the usecs_to_jiffies conditional code part in time.c and
jiffies.h putting it into conditional functions rather than #ifdefs
to improve readability. This is analogous to the msecs_to_jiffies()
cleanup commit ca42aaf0c861 ("time: Refactor msecs_to_jiffies")

Patch was build tested for:
  arm - imx_v6_v7_defconfig, vexpress_defconfig
  cris - etrax-100lx_v2_defconfig
  ia64 - generic_defconfig
  (though with lots of build warnings both with and without patch)
  m68k - multi_defconfig
  mips32 - ar7_defconfig, 
  mips64 - loongson3_defconfig 
  powerpc - 44x/virtex5_defconfig 
  powerpc64 - ppc64_defconfig
  s390 - failed to build for all defconfigs with toolchain from kernel.org
  (cc1: error: unrecognized command line option '-mtune=zEC12')
  sh - se7780_defconfig,
  sparc32 - sparc32_defconfig
  sparc64 - sparc64_defconfig
  x86 64 - x86_64_defconfig,

patch is against 4.1-rc5 (localversion-next is -next-20150527)

Link: http://lkml.org/lkml/2015/5/18/273
Signed-off-by: Nicholas Mc Guire <hofrat@osadl.org>
---

Verification of const folding
config: x86_64_defconfig + CONFIG_DRM_GMA500=m, CONFIG_DRM_GMA3600=y
drivers/gpu/drm/gma500/intel_gmbus.c
204         gpio->algo.timeout = usecs_to_jiffies(2200);                        
-> reduced to load instruction

config: x86_64_defconfig + CONFIG_INFINIBAND=m,  CONFIG_INFINIBAND_QIB=m
drivers/infiniband/hw/qib/qib_qp.c
809	qp->timeout = attr->timeout;
810	qp->timeout_jiffies =
811		usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
812			1000UL);
-> call __usecs_to_jiffies

 include/linux/jiffies.h |   27 ++++++++++++++++++++++++++-
 kernel/time/time.c      |   13 +++----------
 :2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 3bde5eb..cf6eaaf 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -362,7 +362,32 @@ static inline unsigned long msecs_to_jiffies(const unsigned int m)
 	}
 }
 
-extern unsigned long usecs_to_jiffies(const unsigned int u);
+extern unsigned long __usecs_to_jiffies(const unsigned int u);
+#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
+}
+#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return u * (HZ / USEC_PER_SEC);
+}
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+#else
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
+		>> USEC_TO_HZ_SHR32;
+}
+#endif
+
+static inline unsigned long usecs_to_jiffies(const unsigned int u)
+{
+	return __usecs_to_jiffies(u);
+}
+
 extern unsigned long timespec_to_jiffies(const struct timespec *value);
 extern void jiffies_to_timespec(const unsigned long jiffies,
 				struct timespec *value);
diff --git a/kernel/time/time.c b/kernel/time/time.c
index 972e3bb..85d5bb1 100644
--- a/kernel/time/time.c
+++ b/kernel/time/time.c
@@ -522,20 +522,13 @@ unsigned long __msecs_to_jiffies(const unsigned int m)
 }
 EXPORT_SYMBOL(__msecs_to_jiffies);
 
-unsigned long usecs_to_jiffies(const unsigned int u)
+unsigned long __usecs_to_jiffies(const unsigned int u)
 {
 	if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
 		return MAX_JIFFY_OFFSET;
-#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
-	return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
-#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
-	return u * (HZ / USEC_PER_SEC);
-#else
-	return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
-		>> USEC_TO_HZ_SHR32;
-#endif
+	return _usecs_to_jiffies(u);
 }
-EXPORT_SYMBOL(usecs_to_jiffies);
+EXPORT_SYMBOL(__usecs_to_jiffies);
 
 /*
  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
-- 
1.7.10.4

[PATCH 2/2] time: allow gcc to fold constants when possible

[Nicholas Mc Guire]

To allow constant folding in usecs_to_jiffies() conditionally calls
the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
figure out constant folding, __usecs_to_jiffies, which is the renamed
original usecs_to_jiffies() function.

Patch was build tested for:
  arm - imx_v6_v7_defconfig, vexpress_defconfig
  cris - etrax-100lx_v2_defconfig
  ia64 - generic_defconfig
  (though with lots of build warnings both with and without patch)
  m68k - multi_defconfig
  mips32 - ar7_defconfig, 
  mips64 - loongson3_defconfig 
  powerpc - 44x/virtex5_defconfig 
  powerpc64 - ppc64_defconfig
  s390 - failed to build for all defconfigs with toolchain from kernel.org
  (cc1: error: unrecognized command line option '-mtune=zEC12')
  sh - se7780_defconfig,
  sparc32 - sparc32_defconfig
  sparc64 - sparc64_defconfig
  x86 64 - x86_64_defconfig,

patch is against 4.1-rc5 (localversion-next is -next-20150527)

Link: http://lkml.org/lkml/2015/5/18/274
Signed-off-by: Nicholas Mc Guire <hofrat@osadl.org>
---

Thanks to Joe Perches <joe@perches.com> for suggesting this approach.
and helping with the initial msecs_to_jiffies cleanup patch.

Verification of const folding:
config: x86_64_defconfig + CONFIG_DRM_GMA500=m, CONFIG_DRM_GMA3600=y
drivers/gpu/drm/gma500/intel_gmbus.c
204         gpio->algo.timeout = usecs_to_jiffies(2200);                        
-> reduced to load instruction

config: x86_64_defconfig + CONFIG_INFINIBAND=m,  CONFIG_INFINIBAND_QIB=m
drivers/infiniband/hw/qib/qib_qp.c
809     qp->timeout = attr->timeout;
810     qp->timeout_jiffies =
811             usecs_to_jiffies((4096UL * (1UL << qp->timeout)) /
812                     1000UL);
-> call __usecs_to_jiffies

 include/linux/jiffies.h |   30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index cf6eaaf..c0aa150 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -383,9 +383,37 @@ static inline unsigned long _usecs_to_jiffies(const unsigned int u)
 }
 #endif
 
+/**
+ * usecs_to_jiffies: - convert microseconds to jiffies
+ * @u:	time in microseconds
+ *
+ * conversion is done as follows:
+ *
+ * - 'too large' values [that would result in larger than
+ *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
+ *
+ * - all other values are converted to jiffies by either multiplying
+ *   the input value by a factor or dividing it with a factor and
+ *   handling any 32-bit overflows as for msecs_to_jiffies.
+ *
+ * usecs_to_jiffies() checks for the passed in value being a constant
+ * via __builtin_constant_p() allowing gcc to eliminate most of the
+ * code, __usecs_to_jiffies() is called if the value passed does not
+ * allow constant folding and the actual conversion must be done at
+ * runtime.
+ * the HZ range specific helpers _usecs_to_jiffies() are called both
+ * directly here and from __msecs_to_jiffies() in the case where
+ * constant folding is not possible.
+ */
 static inline unsigned long usecs_to_jiffies(const unsigned int u)
 {
-	return __usecs_to_jiffies(u);
+	if (__builtin_constant_p(u)) {
+		if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
+			return MAX_JIFFY_OFFSET;
+		return _usecs_to_jiffies(u);
+	} else {
+		return __usecs_to_jiffies(u);
+	}
 }
 
 extern unsigned long timespec_to_jiffies(const struct timespec *value);
-- 
1.7.10.4

Re: [PATCH 2/2] time: allow gcc to fold constants when possible

[Joe Perches]

On Thu, 2015-05-28 at 19:09 +0200, Nicholas Mc Guire wrote:
> To allow constant folding in usecs_to_jiffies() conditionally calls
> the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
> figure out constant folding, __usecs_to_jiffies, which is the renamed
> original usecs_to_jiffies() function.

Hi Nicholas.

Thanks for following through with this.

The subject might be nicer if it referenced usecs_to_jiffies
instead of being a bit generic.

Maybe something like:

time: allow gcc to fold usecs_to_jiffies(constant)

Re: [PATCH 2/2] time: allow gcc to fold constants when possible

[Thomas Gleixner]

On Thu, 28 May 2015, Joe Perches wrote:
> On Thu, 2015-05-28 at 19:09 +0200, Nicholas Mc Guire wrote:
> > To allow constant folding in usecs_to_jiffies() conditionally calls
> > the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
> > figure out constant folding, __usecs_to_jiffies, which is the renamed
> > original usecs_to_jiffies() function.
> 
> Hi Nicholas.
> 
> Thanks for following through with this.
> 
> The subject might be nicer if it referenced usecs_to_jiffies
> instead of being a bit generic.
> 
> Maybe something like:
> 
> time: allow gcc to fold usecs_to_jiffies(constant)

And for correctness sake the first letter after the colon, i.e. the
one starting the sentence wants to be uppercase.

I'm going to fix that up all together when applying the lot. No need
for resend.

Thanks,

	tglx

Re: [PATCH 2/2] time: allow gcc to fold constants when possible

[John Stultz]

On Tue, Jun 2, 2015 at 2:23 PM, Thomas Gleixner <tglx@linutronix.de> wrote:
> On Thu, 28 May 2015, Joe Perches wrote:
>> On Thu, 2015-05-28 at 19:09 +0200, Nicholas Mc Guire wrote:
>> > To allow constant folding in usecs_to_jiffies() conditionally calls
>> > the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
>> > figure out constant folding, __usecs_to_jiffies, which is the renamed
>> > original usecs_to_jiffies() function.
>>
>> Hi Nicholas.
>>
>> Thanks for following through with this.
>>
>> The subject might be nicer if it referenced usecs_to_jiffies
>> instead of being a bit generic.
>>
>> Maybe something like:
>>
>> time: allow gcc to fold usecs_to_jiffies(constant)
>
> And for correctness sake the first letter after the colon, i.e. the
> one starting the sentence wants to be uppercase.

Is this something that would be worth adding to checkpatch?

thanks
-john

Re: [PATCH 2/2] time: allow gcc to fold constants when possible

[Joe Perches]

On Tue, 2015-06-02 at 14:31 -0700, John Stultz wrote:
> On Tue, Jun 2, 2015 at 2:23 PM, Thomas Gleixner <tglx@linutronix.de> wrote:
> > On Thu, 28 May 2015, Joe Perches wrote:
> >> On Thu, 2015-05-28 at 19:09 +0200, Nicholas Mc Guire wrote:
> >> > To allow constant folding in usecs_to_jiffies() conditionally calls
> >> > the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
> >> > figure out constant folding, __usecs_to_jiffies, which is the renamed
> >> > original usecs_to_jiffies() function.
> >>
> >> Hi Nicholas.
> >>
> >> Thanks for following through with this.
> >>
> >> The subject might be nicer if it referenced usecs_to_jiffies
> >> instead of being a bit generic.
> >>
> >> Maybe something like:
> >>
> >> time: allow gcc to fold usecs_to_jiffies(constant)
> >
> > And for correctness sake the first letter after the colon, i.e. the
> > one starting the sentence wants to be uppercase.
> 
> Is this something that would be worth adding to checkpatch?

Probably not as different people have different standards.

$ git log --no-merges --pretty=oneline -10000 | \
  cut -f2- -d" " | \
  sed -r -e 's/^.*:\s+//' -e 's/^(.).*/\1/' | \
  sort | uniq -c

It's about 50:50 upper case to lower case

Re: [PATCH 2/2] time: allow gcc to fold constants when possible

[Nicholas Mc Guire]

On Tue, 02 Jun 2015, Thomas Gleixner wrote:

> On Thu, 28 May 2015, Joe Perches wrote:
> > On Thu, 2015-05-28 at 19:09 +0200, Nicholas Mc Guire wrote:
> > > To allow constant folding in usecs_to_jiffies() conditionally calls
> > > the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
> > > figure out constant folding, __usecs_to_jiffies, which is the renamed
> > > original usecs_to_jiffies() function.
> > 
> > Hi Nicholas.
> > 
> > Thanks for following through with this.
> > 
> > The subject might be nicer if it referenced usecs_to_jiffies
> > instead of being a bit generic.
> > 
> > Maybe something like:
> > 
> > time: allow gcc to fold usecs_to_jiffies(constant)
> 
> And for correctness sake the first letter after the colon, i.e. the
> one starting the sentence wants to be uppercase.
> 
added to my list of checks - sorry for being sloppy on that

> I'm going to fix that up all together when applying the lot. No need
> for resend.
>

thanks !
hofrat

[tip:timers/core] time: Refactor usecs_to_jiffies

[tip-bot for Nicholas Mc Guire]

Commit-ID:  ae60d6a0e3a9197d37f8c8c4584a8ecd18518cd6
Gitweb:     http://git.kernel.org/tip/ae60d6a0e3a9197d37f8c8c4584a8ecd18518cd6
Author:     Nicholas Mc Guire <hofrat@osadl.org>
AuthorDate: Thu, 28 May 2015 19:09:55 +0200
Committer:  Thomas Gleixner <tglx@linutronix.de>
CommitDate: Wed, 10 Jun 2015 11:31:13 +0200

time: Refactor usecs_to_jiffies

Refactor the usecs_to_jiffies conditional code part in time.c and
jiffies.h putting it into conditional functions rather than #ifdefs
to improve readability. This is analogous to the msecs_to_jiffies()
cleanup in commit ca42aaf0c861 ("time: Refactor msecs_to_jiffies")

Signed-off-by: Nicholas Mc Guire <hofrat@osadl.org>
Cc: Masahiro Yamada <yamada.m@jp.panasonic.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Joe Perches <joe@perches.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Andrew Hunter <ahh@google.com>
Cc: Paul Turner <pjt@google.com>
Cc: Michal Marek <mmarek@suse.cz>
Link: http://lkml.kernel.org/r/1432832996-12129-1-git-send-email-hofrat@osadl.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
---
 include/linux/jiffies.h | 27 ++++++++++++++++++++++++++-
 kernel/time/time.c      | 13 +++----------
 2 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 3bde5eb..a316ebe 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -362,7 +362,32 @@ static inline unsigned long msecs_to_jiffies(const unsigned int m)
 	}
 }
 
-extern unsigned long usecs_to_jiffies(const unsigned int u);
+extern unsigned long __usecs_to_jiffies(const unsigned int u);
+#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
+}
+#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return u * (HZ / USEC_PER_SEC);
+}
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+#else
+static inline unsigned long _usecs_to_jiffies(const unsigned int u)
+{
+	return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
+		>> USEC_TO_HZ_SHR32;
+}
+#endif
+
+static inline unsigned long usecs_to_jiffies(const unsigned int u)
+{
+	return __usecs_to_jiffies(u);
+}
+
 extern unsigned long timespec_to_jiffies(const struct timespec *value);
 extern void jiffies_to_timespec(const unsigned long jiffies,
 				struct timespec *value);
diff --git a/kernel/time/time.c b/kernel/time/time.c
index 972e3bb..85d5bb1 100644
--- a/kernel/time/time.c
+++ b/kernel/time/time.c
@@ -522,20 +522,13 @@ unsigned long __msecs_to_jiffies(const unsigned int m)
 }
 EXPORT_SYMBOL(__msecs_to_jiffies);
 
-unsigned long usecs_to_jiffies(const unsigned int u)
+unsigned long __usecs_to_jiffies(const unsigned int u)
 {
 	if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
 		return MAX_JIFFY_OFFSET;
-#if HZ <= USEC_PER_SEC && !(USEC_PER_SEC % HZ)
-	return (u + (USEC_PER_SEC / HZ) - 1) / (USEC_PER_SEC / HZ);
-#elif HZ > USEC_PER_SEC && !(HZ % USEC_PER_SEC)
-	return u * (HZ / USEC_PER_SEC);
-#else
-	return (USEC_TO_HZ_MUL32 * u + USEC_TO_HZ_ADJ32)
-		>> USEC_TO_HZ_SHR32;
-#endif
+	return _usecs_to_jiffies(u);
 }
-EXPORT_SYMBOL(usecs_to_jiffies);
+EXPORT_SYMBOL(__usecs_to_jiffies);
 
 /*
  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note

[tip:timers/core] time: Allow gcc to fold usecs_to_jiffies( constant)

[tip-bot for Nicholas Mc Guire]

Commit-ID:  c569a23d65ac2900d9998d3fe04044fe95be6b2f
Gitweb:     http://git.kernel.org/tip/c569a23d65ac2900d9998d3fe04044fe95be6b2f
Author:     Nicholas Mc Guire <hofrat@osadl.org>
AuthorDate: Thu, 28 May 2015 19:09:56 +0200
Committer:  Thomas Gleixner <tglx@linutronix.de>
CommitDate: Wed, 10 Jun 2015 11:31:14 +0200

time: Allow gcc to fold usecs_to_jiffies(constant)

To allow constant folding in usecs_to_jiffies() conditionally calls
the HZ dependent _usecs_to_jiffies() helpers or, when gcc can not
figure out constant folding, __usecs_to_jiffies, which is the renamed
original usecs_to_jiffies() function.

Signed-off-by: Nicholas Mc Guire <hofrat@osadl.org>
Cc: Masahiro Yamada <yamada.m@jp.panasonic.com>
Cc: Sam Ravnborg <sam@ravnborg.org>
Cc: Joe Perches <joe@perches.com>
Cc: John Stultz <john.stultz@linaro.org>
Cc: Andrew Hunter <ahh@google.com>
Cc: Paul Turner <pjt@google.com>
Cc: Michal Marek <mmarek@suse.cz>
Link: http://lkml.kernel.org/r/1432832996-12129-2-git-send-email-hofrat@osadl.org
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
---
 include/linux/jiffies.h | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index a316ebe..535fd3b 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -383,9 +383,37 @@ static inline unsigned long _usecs_to_jiffies(const unsigned int u)
 }
 #endif
 
+/**
+ * usecs_to_jiffies: - convert microseconds to jiffies
+ * @u:	time in microseconds
+ *
+ * conversion is done as follows:
+ *
+ * - 'too large' values [that would result in larger than
+ *   MAX_JIFFY_OFFSET values] mean 'infinite timeout' too.
+ *
+ * - all other values are converted to jiffies by either multiplying
+ *   the input value by a factor or dividing it with a factor and
+ *   handling any 32-bit overflows as for msecs_to_jiffies.
+ *
+ * usecs_to_jiffies() checks for the passed in value being a constant
+ * via __builtin_constant_p() allowing gcc to eliminate most of the
+ * code, __usecs_to_jiffies() is called if the value passed does not
+ * allow constant folding and the actual conversion must be done at
+ * runtime.
+ * the HZ range specific helpers _usecs_to_jiffies() are called both
+ * directly here and from __msecs_to_jiffies() in the case where
+ * constant folding is not possible.
+ */
 static inline unsigned long usecs_to_jiffies(const unsigned int u)
 {
-	return __usecs_to_jiffies(u);
+	if (__builtin_constant_p(u)) {
+		if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
+			return MAX_JIFFY_OFFSET;
+		return _usecs_to_jiffies(u);
+	} else {
+		return __usecs_to_jiffies(u);
+	}
 }
 
 extern unsigned long timespec_to_jiffies(const struct timespec *value);