Provided by: manpages-fr-dev_3.17.1-1_all bug

NOM

       clock_nanosleep - Sommeil haute résolution avec horloge spécifique

SYNOPSIS

       #include <time.h>

       int clock_nanosleep(clockid_t clock_id, int flags,
                           const struct timespec *request,
                           struct timespec *remain);

       Effectuez l’édition des liens avec l’option -lrt.

   Exigences  de  macros  de  test  de  fonctionnalités  pour  la  glibc (voir
   feature_test_macros(7)) :

       clock_nanosleep() : _XOPEN_SOURCE >= 600

DESCRIPTION

       Comme nanosleep(2), clock_nanosleep() permet à l’appelant de sommeiller
       pendant  une  durée  indiquée  avec une précision de la nanoseconde. Il
       diffère de nanosleep(2) dans le  fait  qu’il  permet  à  l’appelant  de
       choisir  l’horloge  avec  laquelle  la durée du sommeil sera mesurée et
       d’indiquer une valeur absolue ou relative pour la durée du sommeil.

       Les valeurs de temps  passées  à  ou  retournées  par  cet  appel  sont
       spécifiés dans des structures timespec définies comme suit :

           struct timespec {
               time_t tv_sec;        /* secondes */
               long   tv_nsec;       /* nanosecondes [0 .. 999999999] */
           };

       L’argument  clock_id  précise  l’horloge  avec laquelle sera mesurée la
       durée du sommeil. Cet argument doit être l’une des valeurs suivantes :

       CLOCK_REALTIME   Une horloge temps réel  configurable  à  l’échelle  du
                        système.

       CLOCK_MONOTONIC  Une horloge monotonique, non configurable, mesurant le
                        temps depuis un instant du passé non spécifié  qui  ne
                        change pas après le démarrage du système.

       CLOCK_PROCESS_CPUTIME_ID
                        Une  horloge  configurable  par  processus mesurant le
                        temps processeur consommé  par  tous  les  threads  du
                        processus.

       Voir clock_getres(3) pour plus d’informations sur ces horloges.

       Si  flags vaut 0, la valeur indiquée dans request est interprétée comme
       une durée relative à la valeur  actuelle  de  l’horloge  indiquée  dans
       clock_id.

       Si  flags  vaut  TIMER_ABSTIME,  request  est interprété comme un temps
       absolu tel qu’il est mesuré par  l’horloge  clock_id.  Si  request  est
       inférieur  ou égal à la valeur actuelle de l’horloge, clock_nanosleep()
       revient immédiatement sans suspendre le thread appelant.

       clock_nanosleep() suspend l’exécution du thread appelant jusqu’à ce que
       soit le temps indiqué dans request se soit écoulé, soit un signal a été
       délivré provoquant l’appel d’un gestionnaire de signal  ou  la  fin  du
       processus.

       Si   l’appel   a   été   interrompu  par  un  gestionnaire  de  signal,
       clock_nanosleep() renvoie -1 et renseigne errno avec EINTR. De plus, si
       remain  n’est  pas NULL et si flags n’est pas TIMER_ABSTIME, il renvoie
       dans remain le temps de sommeil non consommé. Cette  valeur  peut  être
       ensuite  utilisée pour rappeler clock_nanosleep() et achever un sommeil
       (relatif).

VALEUR RENVOYÉE

       Après un sommeil  complet  de  la  durée  souhaitée,  clock_nanosleep()
       renvoie  0.  Si  l’appel  système est interrompu par un gestionnaire de
       signal ou rencontre une erreur, il renvoie un code d’erreur positif.

ERREURS

       EFAULT request ou remain n’indique pas une adresse valide.

       EINTR  Le sommeil a été interrompu par un gestionnaire de signal.

       EINVAL La valeur du champ tv_nsec  n’est  pas  dans  l’intervalle  0  à
              999 999 999 ou tv_sec est négatif.

       EINVAL clock_id  n’est  pas  valide. (CLOCK_THREAD_CPUTIME_ID n’est pas
              une valeur permise pour clock_id.)

VERSIONS

       L’appel système clock_nanosleep() a été indroduit dans le  noyau  Linux
       dans  sa  version 2.6.  La prise en charge dans la glibc est disponible
       depuis la version 2.1.

CONFORMITÉ

       POSIX.1-2001.

NOTES

       Si la durée indiquée dans request n’est pas un  multiple  exact  de  la
       granularité  de  l’horloge  sous-jacente  (voir time(7)), la durée sera
       alors arrondie au multiple supérieur. De plus, lorsque le sommeil  sera
       achevé,  il y a toujours un délai avant lequel le processeur redevienne
       libre pour exécuter le thread appelant.

       L’utilisation d’une temporisation absolue est utile pour  prévenir  les
       problèmes de dérive de temps du type de ceux décrits dans nanosleep(2).
       (De tels problèmes sont exacerbés dans les programmes qui  essaient  de
       relancer  un  sommeil  relatif interrompu de manière répétitive par des
       signaux.) Pour réaliser un sommeil qui s’affranchisse de ces problèmes,
       appelez  clock_gettime(3)  pour  l’horloge  souhaitée, ajoutez la durée
       voulue à la valeur de temps renvoyée, appelez ensuite clock_nanosleep()
       avec l’attribut TIMER_ABSTIME.

       clock_nanosleep()  n’est  jamais relancé après avoir été interrompu par
       un gestionnaire de signal, que  l’on  ait  ou  non  utilisé  l’attribut
       SA_SIGACTION de sigaction(2).

       L’argument  remain  n’est  pas  utilisé et n’est pas nécessaire lorsque
       flags vaut TIMER_ABSTIME. (Un  sommeil  absolu  peut  être  relancé  en
       utilisant le même argument request.)

       POSIX.1   précise   que  clock_nanosleep()  n’a  aucun  effet  sur  les
       dispositions de signaux ou sur le masque de signaux.

       POSIX.1  précise  qu’après  avoir  modifié  la  valeur   de   l’horloge
       CLOCK_REALTIME  avec  clock_settime(3), la nouvelle valeur de l’horloge
       doit être utilisée pour déterminer l’heure à laquelle un thread  bloqué
       avec  un  appel clock_nanosleep() absolu se réveillera ; si la nouvelle
       horloge fait que la durée du  sommeil  est  dépassée,  l’appel  système
       clock_nanosleep() revient immédiatement.

       POSIX.1 précise que modifier la valeur de l’horloge CLOCK_REALTIME avec
       clock_settime(3) n’a pas d’effet sur un  thread  bloqué  par  un  appel
       clock_nanosleep() absolu.

VOIR AUSSI

       nanosleep(2),  clock_getres(3),  sleep(3),  timer_create(3), usleep(3),
       time(7)

COLOPHON

       Cette page fait partie de  la  publication  3.17  du  projet  man-pages
       Linux.  Une description du projet et des instructions pour signaler des
       anomalies      peuvent      être       trouvées       à       l’adresse
       http://www.kernel.org/doc/man-pages/.

TRADUCTION

       Cette  page  de  manuel  a  été  traduite  par Alain Portal <aportal AT
       univ-montp2  DOT   fr>   en   2008,   et   mise   à   disposition   sur
       http://manpagesfr.free.fr/.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».