time

TIME(7)                   Manuel du programmeur Linux                  TIME(7)



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.70 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 Ã
       <perkamon-fr@traduc.org>.

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



Linux                           28 octobre 2012                        TIME(7)