LDP
/
man-pages
mirror of https://github.com/mkerrisk/man-pages
0
1
Fork 0
Code Releases Activity
man-pages/man2/getitimer.2

177 lines
4.6 KiB
Groff
Raw Normal View History

Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.\" Copyright 7/93 by Darren Senn <sinster@scintilla.santa-clara.ca.us>
.\" Based on a similar page Copyright 1992 by Rick Faith
.\" May be freely distributed
.\" Modified Tue Oct 22 00:22:35 EDT 1996 by Eric S. Raymond <esr@thyrsus.com>
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
.\" 2005-04-06 mtk, Matthias Lang <matthias@corelatus.se>
.\" Noted MAX_SEC_IN_JIFFIES ceiling
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.TH GETITIMER 2 1993-08-05 "Linux 0.99.11" "Linux Programmer's Manual"
.SH NAME
getitimer, setitimer \- get or set value of an interval timer
.SH SYNOPSIS
.PD 0
.HP
.B #include <sys/time.h>
.sp
.HP
.B int getitimer(int
.IB which ,
.B struct itimerval
.BI * value );
.HP
.B int setitimer(int
.IB which ,
.B const struct itimerval
.BI * value ,
.B struct itimerval
.BI * ovalue );
.PD
.SH DESCRIPTION
The system provides each process with three interval timers, each decrementing
in a distinct time domain. When any timer expires, a signal is sent to the
process, and the timer (potentially) restarts.
.TP 1.5i
.B ITIMER_REAL
decrements in real time, and delivers
.B SIGALRM
upon expiration.
.TP
.B ITIMER_VIRTUAL
decrements only when the process is executing, and delivers
.B SIGVTALRM
upon expiration.
.TP
.B ITIMER_PROF
decrements both when the process executes and when the system is executing
on behalf of the process. Coupled with
.BR ITIMER_VIRTUAL ,
this timer is usually used to profile the time spent by the application in user
and kernel space.
.B SIGPROF
is delivered upon expiration.
.LP
Timer values are defined by the following structures:
.PD 0
.RS .5i
.nf
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
struct itimerval {
struct timeval it_interval; /* next value */
struct timeval it_value; /* current value */
};
struct timeval {
long tv_sec; /* seconds */
long tv_usec; /* microseconds */
};
.fi
.RE
.PD
.LP
The function
.B getitimer
fills the structure indicated by
.I value
with the current setting for the timer indicated by
.I which
(one of
.BR ITIMER_REAL ,
.BR ITIMER_VIRTUAL ,
or
.BR ITIMER_PROF ).
The element
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
.I it_value
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
is set to the amount of time remaining on the timer, or zero if the timer
is disabled. Similarly,
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
.I it_interval
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
is set to the reset value.
The function
.B setitimer
sets the indicated timer to the value in
.IR value .
If
.I ovalue
Global edit: s/nonzero/non-zero/
2005-06-15 13:32:34 +00:00
is non-zero, the old value of the timer is stored there.
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.LP
Timers decrement from
.I it_value
to zero, generate a signal, and reset to
.IR it_interval .
A timer which is set to zero
.RI ( it_value
is zero or the timer expires and
.I it_interval
is zero) stops.
.LP
Both
.I tv_sec
and
.I tv_usec
are significant in determining the duration of a timer.
.LP
Timers will never expire before the requested time,
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
but may expire some (short) time afterwards, which depends
on the system timer resolution and on the system load.
Minor changes
2005-06-21 13:50:30 +00:00
(But see BUGS below.)
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
Upon expiration, a signal will be generated and the timer reset.
If the timer expires while the process is active (always true for
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.BR ITIMER_VIRT )
the signal will be delivered immediately when generated. Otherwise the
delivery will be offset by a small time dependent on the system loading.
.LP
.SH "RETURN VALUE"
On success, zero is returned. On error, \-1 is returned, and
.I errno
is set appropriately.
.SH ERRORS
.TP
.B EFAULT
.I value
or
.I ovalue
are not valid pointers.
.TP
.B EINVAL
.I which
is not one of
.BR ITIMER_REAL ,
.BR ITIMER_VIRT ,
or
.BR ITIMER_PROF .
.SH "CONFORMING TO"
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
POSIX.1-2001, SVr4, 4.4BSD (this call first appeared in 4.2BSD).
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.SH "SEE ALSO"
.BR gettimeofday (2),
.BR sigaction (2),
.BR signal (2)
.SH BUGS
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
The generation and delivery of a signal are distinct, and
only one instance of each of the signals listed above may be pending
for a process.
Under very heavy loading, an
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
.B ITIMER_REAL
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
timer may expire before the signal from a previous expiration
has been delivered.
Import of man-pages 1.70
2004-11-03 13:51:07 +00:00
The second signal in such an event will be lost.
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
On Linux, timer values are represented in jiffies.
If a request is made set a timer with a value whose jiffies
representation exceeds MAX_SEC_IN_JIFFIES
(defined in
.IR include/linux/jiffies.h ),
then the timer is silently truncated to this ceiling value.
On Linux 2.6 on x86 (where a jiffy is 0.001 seconds),
this means that the ceiling value for a timer is
approximately 24.86 days.
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
On certain systems (including x86), the Linux kernel has a bug which will
produce premature timer expirations of up to one jiffy under some
circumstances.
Minor changes
2005-06-21 13:50:30 +00:00
.\" As at June 2005, the above holds in 2.4.x and 2.6.x (e.g., 2.6.12.)
Salut Olivier (and Nishanth), Regarding man page documentation of the problem of short sleeps for setiteimer(2)... > > -- pointers to those threads > > http://bugzilla.kernel.org/show_bug.cgi?id=4569 > http://lkml.org/lkml/2005/4/29/163 > > > -- indications of which kernel versions show this bahaviour > > AFAIK, all versions as far as x86 is concerned. > Dunno if it is hardware specific. > > > -- a (short) test program to demonstrate it, if you have one. > > See the bugzilla bug's attachments Sorry for the long delay in following this up, but I've got to it now. I tweaked your suggestions slightly: {{ Timers will never expire before the requested time, -instead expiring some short, constant time afterwards, dependent -on the system timer resolution (currently 10ms). +but may expire some (short) time afterwards, which depends +on the system timer resolution and on the system load. +Upon expiration, a signal will be generated and the timer reset. +If the timer expires while the process is active (always true for +On certain systems (including x86), the Linux kernel has a bug which will +produce premature timer expirations of up to one jiffy under some +circumstances. }} Thanks for this bug reporet, Nishanth: if and when your changes are accepted, and the problem is thus fixed, could you please send me a notification of that fact, and I can then further amend the manual pages. Cheers, Michael /* itimer_short_interval_bug.c June 2005 In current Linux kernels, an interval timer set using setitimer() can sometimes sleep *less* than the specified interval. This program demonstrates the behaviour by looping through all itimer values from 1 microsecond upwards, in one microsecond steps. */ /* Adapted from a program by Olivier Croquette, June 2005 */ #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <sys/time.h> #include <sys/wait.h> typedef unsigned long long int u_time_t; /* in microsecs */ static int handler_flag; /* return time as a number of microsecs */ static u_time_t gettime(void ) { struct timeval tv; if ( gettimeofday(&tv, NULL) == -1) { perror("gettimeofday()"); return 0; } return (tv.tv_usec + tv.tv_sec * 1000000LL); } static void handler (int sig, siginfo_t *siginfo, void *context) { handler_flag++; return ; } /* Sleep for 'time' microsecs. */ static int isleep(u_time_t time) { struct itimerval newtv; sigset_t sigset; struct sigaction sigact; if (time == 0) return 0; /* block SIGALRM */ sigemptyset (&sigset); sigaddset (&sigset, SIGALRM); sigprocmask (SIG_BLOCK, &sigset, NULL); /* set up our handler */ sigact.sa_sigaction = handler; sigemptyset(&sigact.sa_mask); sigact.sa_flags = SA_SIGINFO; sigaction (SIGALRM, &sigact, NULL); newtv.it_interval.tv_sec = 0; newtv.it_interval.tv_usec = 0; newtv.it_value.tv_sec = time / 1000000; newtv.it_value.tv_usec = time % 1000000; if (setitimer(ITIMER_REAL,&newtv,NULL) == -1) { perror("setitimer(set)"); return 1; } sigemptyset (&sigset); sigsuspend (&sigset); return 0; } int main(int argc, char *argv[]) { u_time_t wait; int loop, numLoops; u_time_t t1, t2; u_time_t actual; long long minDiff, maxDiff, totDiff, diff; int numFail = 0; if (argc != 2) { fprintf(stderr, "Usage: %s num-loops\n", argv[0]); exit(EXIT_FAILURE); } /* if */ numLoops = atoi(argv[1]); setbuf(stdout, NULL); for (wait = 1; ; wait++) { maxDiff = 0; numFail = 0; totDiff = 0; minDiff = -wait; if (wait % 10000 == 0) printf("%llu\n", wait); for (loop = 0; loop < numLoops; loop++) { t1 = gettime(); handler_flag = 0; isleep(wait); if ( handler_flag != 1 ) printf("Problem with the handler flag (%d)!\n", handler_flag); t2 = gettime(); actual = t2 - t1; if ( actual < wait ) { diff = actual - wait; if (diff < maxDiff) maxDiff = diff; if (diff > minDiff) minDiff = diff; totDiff += diff; numFail++; } /* if */ } /* for */ if (numFail > 0) printf("%llu: %3d fail (%4lld %4lld; avg=%6.1f)\n", wait, numFail, minDiff, maxDiff, (double) totDiff / numFail); } /* for */ return 0; } /* main */
2005-06-13 09:01:49 +00:00
Matthias Lang, mtk Noted MAX_SEC_IN_JIFFIES ceiling. Added note about treatment of out-of-range tv_usec values.
2005-04-06 15:29:32 +00:00
POSIX.1 says that
.B setitimer
should fail if a
.I tv_usec
value is specified that is outside of the range 0 to 999999.
However, Linux does not give an error, but instead silently
adjusts the corresponding seconds value for the timer.