Converting jiffies to milli seconds

Question

How do I manually convert jiffies to milliseconds and vice versa in Linux? I know kernel 2.6 has a function for this, but I'm working on 2.4 (homework) and though I looked at the code it uses lots of macro constants which I have no idea if they're defined in 2.4.

Answer 1

Jiffies are hard-coded in Linux 2.4. Check the definition of HZ, which is defined in the architecture-specific param.h. It's often 100 Hz, which is one tick every (1 sec/100 ticks * 1000 ms/sec) 10 ms.

This holds true for i386, and HZ is defined in include/asm-i386/param.h.

There are functions in include/linux/time.h called timespec_to_jiffies and jiffies_to_timespec where you can convert back and forth between a struct timespec and jiffies:

   29 #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
   30 
   31 static __inline__ unsigned long
   32 timespec_to_jiffies(struct timespec *value)
   33 {
   34         unsigned long sec = value->tv_sec;
   35         long nsec = value->tv_nsec;
   36 
   37         if (sec >= (MAX_JIFFY_OFFSET / HZ))
   38                 return MAX_JIFFY_OFFSET;
   39         nsec += 1000000000L / HZ - 1;
   40         nsec /= 1000000000L / HZ;
   41         return HZ * sec + nsec;
   42 }
   43 
   44 static __inline__ void
   45 jiffies_to_timespec(unsigned long jiffies, struct timespec *value)
   46 {
   47         value->tv_nsec = (jiffies % HZ) * (1000000000L / HZ);
   48         value->tv_sec = jiffies / HZ;
   49 }
   50 

Note I checked this info in version 2.4.22.

Answer 2

As a previous answer said, the rate at which jiffies increments is fixed.

The standard way of specifying time for a function that accepts jiffies is using the constant HZ.

That's the abbreviation for Hertz, or the number of ticks per second. On a system with a timer tick set to 1ms, HZ=1000. Some distributions or architectures may use another number (100 used to be common).

The standard way of specifying a jiffies count for a function is using HZ, like this:

schedule_timeout(HZ / 10);  /* Timeout after 1/10 second */

In most simple cases, this works fine.

2*HZ     /* 2 seconds in jiffies */
HZ       /* 1 second in jiffies */
foo * HZ /* foo seconds in jiffies */
HZ/10    /* 100 milliseconds in jiffies */
HZ/100   /* 10 milliseconds in jiffies */
bar*HZ/1000 /* bar milliseconds in jiffies */

Those last two have a bit of a problem, however, as on a system with a 10 ms timer tick, HZ/100 is 1, and the precision starts to suffer. You may get a delay anywhere between 0.0001 and 1.999 timer ticks (0-2 ms, essentially). If you tried to use HZ/200 on a 10ms tick system, the integer division gives you 0 jiffies!

So the rule of thumb is, be very careful using HZ for tiny values (those approaching 1 jiffie).

To convert the other way, you would use:

jiffies / HZ          /* jiffies to seconds */
jiffies * 1000 / HZ   /* jiffies to milliseconds */

You shouldn't expect anything better than millisecond precision.