Unix & Linux Stack Exchange is a question and answer site for users of Linux, FreeBSD and other Un*x-like operating systems. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

Jiffies in most Linux system are defaulted to 250 (4ms). The questions is that what happens when a program has a usleep() less then 4ms ? Of course it works as should when it is scheduled. But what happens when linux scheduler takes out this program to wait, because another program has to operate ? How does the preemption works in this case?

Should I avoid custom programs with such a small waiting? They couldn't be accurate, could it ?

share|improve this question
up vote 6 down vote accepted

See time(7), and the manpages it references. An excerpt:

High-Resolution Timers
   Before Linux 2.6.21, the accuracy of timer and sleep system calls  (see
   below) was also limited by the size of the jiffy.

   Since  Linux  2.6.21,  Linux  supports  high-resolution  timers (HRTs),
   optionally configurable via CONFIG_HIGH_RES_TIMERS.  On a  system  that
   supports  HRTs,  the  accuracy  of  sleep  and timer system calls is no
   longer constrained by the jiffy, but instead can be as accurate as  the
   hardware  allows  (microsecond accuracy is typical of modern hardware).
   You can determine  whether  high-resolution  timers  are  supported  by
   checking  the resolution returned by a call to clock_getres(2) or look‐
   ing at the "resolution" entries in /proc/timer_list.

   HRTs are not supported on all hardware architectures.  (Support is pro‐
   vided on x86, arm, and powerpc, among others.)

A comment suggests that you can't sleep less than a jiffy. That is incorrect; with HRTs, you can. Try this program:

/* test_hrt.c */
#include <time.h>
        struct timespec ts;
        int i;

        ts.tv_sec = 0;
        ts.tv_nsec = 500000;  /* 0.5 milliseconds */
        for (i = 0; i < 1000; i++) {
                clock_nanosleep(CLOCK_MONOTONIC, 0, &ts, NULL);

Compile it:

$ gcc -o test_hrt test_hrt.c -lrt

Run it:

$ time ./test_hrt

real    0m0.598s
user    0m0.008s
sys     0m0.016s

As you can see, 1000 iterations of a 0.5 millisecond delay took just a little over 0.5 seconds, as expected. If clock_nanosleep were truly waiting until the next jiffy before returning, it would have taken at least 4 seconds.

Now the original question was, what happens if your program was scheduled out during that time? And the answer is that it depends on the priority. Even if another program gets scheduled while your program is running, if your program is higher priority, or the scheduler decides that it's your program's time to run, it will start executing again after the clock_nanosleep timeout returns. It does not need to wait until the next jiffy for that to happen. You can try running the test program above while running other software that takes the CPU, and you'll see that it still executes in the same amount of time, especially if you increase the priority with e.g.

$ time sudo schedtool -R -p 99 -e ./test_hrt
share|improve this answer
True, but the scheduler still runs with jiffies, while a (hardware) alarm can appear now between two jiffies... – Nils Nov 9 '12 at 21:47
... and trigger an immediate wakeup for your process. What's your point? Sure, if you have a higher priority process also running then the scheduler might decide that the other process gets to run instead of you, but that's always a problem on a multitasking operating system, and can be solved with appropriate application of SCHED_RR, SCHED_FIFO, priorities, etc. – Jim Paris Nov 9 '12 at 22:06
The point is that the scheduler will not react "immediately" - it takes at least a full jiffie to react. That is the core problem of the question. So these high-precision timers help to MEASURE time more accurate - but they do not help for more fine-granular scheduling. – Nils Nov 9 '12 at 22:19
That's simply not true. You can sleep for less than a jiffy. See my edit. – Jim Paris Nov 9 '12 at 22:38
Great edit +1 for your answer now. I did not know that a wakeup can happen between jiffies. – Nils Nov 10 '12 at 22:30

Unless you're running a realtime kernel, I wouldn't use sleep times < 10ms anyway tbh. Even if the scheduler is willing to pre-empt another process for your timeout, jitter will probably dominate your actual sleep times.

Summary: avoid such small intervals unless you have a realtime kernel. If you can't change kernel, your best bet may be to pin your process to a dedicated CPU with SCHED_FIFO and busy-wait (or do other useful work) for anything less than about two jiffies.

Somehow the summary ended up longer than the original ... oh well.

share|improve this answer

Your Answer


By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.