NOM

       time - Panorama des fonctions liées au temps et aux temporisations

DESCRIPTION

   Temps réel et temps processus
       Le  temps  réel  est  défini comme le temps mesuré à partir d'un point fixe, soit un point
       standard dans le passé (voir la définition de l'époque et du temps calendaire ci‐dessous),
       soit un point (p.ex. le démarrage) dans la vie d'un processus (temps écoulé).

       Le  temps processus est défini comme le temps CPU utilisé par un processus. Il est parfois
       divisé entre une partie utilisateur et une partie système. Le temps CPU utilisateur est le
       temps  passé  à  exécuter  du  code en mode utilisateur. Le temps CPU système est le temps
       passé par le noyau en mode système pour le processus (p.ex. pendant des  appels  système).
       La  commande  time(1)  peut  être  utilisée  pour  déterminer le temps CPU utilisé pendant
       l'exécution du programme. Un programme peut déterminer le temps CPU qu'il a  utilisé  avec
       les fonctions times(2), getrusage(2) et clock(3).

   L'horloge matérielle
       La  plupart  des  ordinateurs  ont  une horloge matérielle (alimentée par une pile) que le
       noyau lit au démarrage du système pour initialiser  l'horloge  logicielle.  Pour  plus  de
       détails, consultez rtc(4) et hwclock(8).

   L'horloge logicielle, HZ, et les Jiffies
       La  précision  de divers appels système qui définissent des délais (par exemple select(2),
       sigtimedwait(2)) ou qui mesurent  le  temps  processeur  (par  exemple  getrusage(2))  est
       limitée  par la résolution de l'horloge logicielle, une horloge maintenue par le noyau qui
       mesure le temps en jiffies. La durée d'un  jiffy  est  déterminée  par  la  valeur  de  la
       constante noyau HZ.

       La  précision  de  nombreux appels système et horodatages est limitée par la résolution de
       l'horloge logicielle, une horloge maintenue par le noyau qui mesure le temps  en  jiffies.
       La  taille  d'un jiffy est déterminée par la valeur de la constante du noyau HZ. La valeur
       de HZ varie d'une version du noyau et  d'une  architecture  à  une  autre.  Sur  i386,  la
       situation  est  la  suivante :  pour  les noyaux jusqu'à 2.4.x inclus, HZ vaut 100, ce qui
       donne une valeur de jiffy de 10 millisecondes ; à partir de 2.6.0, HZ  a  été  augmenté  à
       1000,  ainsi un jiffy était équivalent à 1 milliseconde. Depuis le noyau 2.6.13, la valeur
       de HZ est un paramètre de configuration du noyau, et peut valoir 100, 250 (la  valeur  par
       défaut), ou 1000, donnant des valeurs de 10, 4 et 1 millisecondes, respectivement, pour un
       jiffy. Depuis le noyau 2.6.20, il est aussi possible d'utiliser  300 ;  cette  valeur  est
       divisible  par  les  fréquences  des  formats vidéos les plus courants (PAL, 25 Hz ; NTSC,
       30 Hz).

       L'appel système times(2) est un cas particulier. Il renvoie le temps avec une  granularité
       définie par la constante du noyau USER_HZ. Les applications utilisateur peuvent obtenir la
       valeur de cette constante avec sysconf(_SC_CLK_TCK).

   Temporisations haute résolution
       Avant Linux 2.6.21, la précision des appels  système  gérant  les  temporisations  et  les
       sommeils (voir plus loin) était limitée par la taille du « jiffy ».

       Depuis   la   version 2.6.21,  Linux  gère  les  temporisations  haute  résolution  (HRT :
       high-resolution timers) de manière optionnelle en configurant CONFIG_HIGH_RES_TIMERS.  Sur
       les  systèmes  gérant les temporisations haute résolution, la précision des appels système
       gérant les temporisations et les sommeils n'est plus limitée par le « jiffy » et peut être
       aussi fine que le système ne le permette (une précision d'une microseconde est typique sur
       les matériels actuels). Vous pouvez savoir si les  temporisations  haute  résolution  sont
       gérées  en  vérifiant la précision renvoyée par un appel à clock_getres(2) ou en regardant
       les entrées « resolution » du fichier /proc/timer_list.

       Les temporisations haute résolution ne  sont  pas  gérées  par  toutes  les  architectures
       matérielles. Cette gestion est disponible sur x86, arm et powerpc parmi d'autres.

   L'époque (Epoch)
       Les  systèmes  UNIX  représentent le temps depuis l'époque (Epoch), qui est le 1er janvier
       1970 à 00:00:00 (UTC).

       Un programme peut déterminer le temps calendaire  avec  gettimeofday(2),  qui  renvoie  le
       temps  (en  secondes  et  microsecondes)  écoulé  depuis  l'époque ;  time(2)  fournit une
       information similaire, mais avec une précision d'une seconde. Le temps système  peut  être
       modifié avec settimeofday(2).

   Temps décomposé
       Certaines fonctions de bibliothèque utilisent une structure de type tm pour représenter le
       temps décomposé, qui stocke le temps décomposé en  composantes  distinctes  (année,  mois,
       jour, heure, minute, seconde, etc.). Cette structure est décrite dans ctime(3), qui décrit
       également les fonctions qui font la conversion entre temps calendaire et temps  décomposé.
       Les  fonctions  permettant  les  conversions  entre temps décomposé et représentation sous
       forme de chaîne de caractère sont décrites dans ctime(3), strftime(3) et strptime(3).

   Dormir et placer des temporisations
       Divers appels système et fonctions permettent à un programme de s'endormir (suspendre  son
       exécution)  pour  une  durée  spécifiée.  Consultez  nanosleep(2),  clock_nanosleep(2)  et
       sleep(3).

       Divers appels système permettent à un processus de placer une temporisation qui expirera à
       un  point  donné  dans  le  futur,  et éventuellement à des intervalles répétés. Consultez
       alarm(2), getitimer(2), timerfd_create(2) et timer_create(2).

   Temporisation relâchée
       Depuis Linux 2.6.28, la valeur de « temporisation relâchée » peut être contrôlée  pour  un
       thread.  La  temporisation  relâchée  est  l'intervalle  de  temps pendant lequel le noyau
       pourrait différer le réveil de certains appels qui bloquent avec  un  délai  d'expiration.
       L'autorisation  de  ce  délai  permet  au  noyau de coalescer les événements de réveil, en
       réduisant donc éventuellement le nombre de réveils système et la  consommation  d'énergie.
       Veuillez  consulter la description de PR_SET_TIMERSLACK dans prctl(2) pour obtenir plus de
       précisions.

VOIR AUSSI

       date(1), time(1), adjtimex(2), alarm(2), clock_gettime(2), clock_nanosleep(2),
       getitimer(2), getrlimit(2), getrusage(2), gettimeofday(2), nanosleep(2), stat(2), time(2),
       timer_create(2), timerfd_create(2), times(2), utime(2), adjtime(3), clock(3),
       clock_getcpuclockid(3), ctime(3), pthread_getcpuclockid(3), sleep(3), strftime(3),
       strptime(3), timeradd(3), usleep(3), rtc(4), hwclock(8)

COLOPHON

       Cette page fait partie de la publication 3.57 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

       Depuis 2010, cette traduction est maintenue à l'aide de l'outil po4a
       <http://po4a.alioth.debian.org/> par l'équipe de traduction francophone au sein du projet
       perkamon <http://perkamon.alioth.debian.org/>.

       Julien Cristau et l'équipe francophone de traduction de Debian (2006-2009).

       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> ».