-
Notifications
You must be signed in to change notification settings - Fork 16
/
time.txt
129 lines (110 loc) · 7.4 KB
/
time.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
TIME
HEADER ==> #<time.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
STKT_TM.tm_gmtoff #Décalage horaire par rapport à UTC + heures d'été
#éventuelles, en nombre de secondes, sous forme de
#LONG_INT
STKT_TM.tm_zone #Nom du fuseau horaire, sous forme de STR
timelocal(TM_ADR) #Equivaut à mktime(TM_ADR). Préférer mktime()
timegm(TM_ADR) #Equivaut à mktime(TM_ADR), mais considère que TM_ADR
#est à l'heure UTC et non locale. Faire un mktime()
#après avoir mis temporairement l'environment variable
#TZ à UTC est plus portable.
HEADER ==> #<time.h>
MACROS A DEFINIR ==> #_SVID_SOURCE
stime(TIME_T_ADR) #Le temps courant devient TIME_T_VAL.
----| Renvoie 0 si succès, -1 sinon. Préférer settimeofday()
| ou adjtime()
HEADER ==> #<sys/time.h>
struct timezone #Structure représentant une timezone. Obsolète, ne pas
#utiliser, peut même produire des bugs.
STKT_TMZN.tz_minuteswest#Nombre de minutes par rapport à UTC
STKT_TIMEZONE.tz_dsttime#Heures d'été courantes (s'il y a)
gettimeofday(STKT_TIMEVL#Affecte à STK_TIMEVAL_VAL le temps courant. Ne pas
_ADR, STKT_TIMEZONE_ADR)#utiliser STKT_TIMEZONE_ADR : doit être NULL.
----| Renvoie 0 si succès, -1 sinon.
HEADER ==> #<sys/time.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
settimeofday(STKT_TIMEVL#Le temps courant devient STK_TIMEVAL_VAL. Ne pas
_ADR, STKT_TIMEZONE_ADR)#utiliser STKT_TIMEZONE_ADR : doit être NULL. Préférer
#adjjtime() pour un ajustement léger.
----| Renvoie 0 si succès, -1 sinon.
adjtime(STKT_TIMVAL_ADR,#STKT_TIMVAL_VAR secondes sont ajoutées/retirées (en
STKT_TIMEVAL2_ADR) #fonction du signe de STKT_TIMEVAL_VAR.tv_sec) du temps
#courant.
#Cependant, ce n'est pas immédiat, mais en accélérant ou
#en décélérant légèrement le temps chaque seconde (par
#exemple, pour moi, chaque seconde dure 1.0005 ou 0.9995
#secondes). Ainsi, la transition est douce, ce qui est
#préférable, et évite de nombreux bugs.
#Cependant :
# - cela peut prendre du temps (dans mon cas, une demi-
# heure pour ajuster une seconde)
# - en interne, STKT_TIMEVAL_VAR.tv_sec * 1000000 +
# STKT_TIMEVAL_VAR.tv_usec est enregistré dans un INT
# STKT_TIMEVAL_VAR.tv_sec ne peut donc pas être
# supérieur à INT_MAX / 1000000 (soit 2145 secondes
# pour un système 32 bits, soit 35 minutes)
#STKT_TIMEVAL2_VAR, s'il n'est pas NULL, enregistre les
#secondes d'ajustement restantes devant être encore
#procédées. Cependant, seul un appel d'adjtime() modifie
#ce dernier (il ne l'est pas automatiquement). Ainsi, il
#faut rappeler adjtime() périodiquement pour voir le
#temps qu'il reste à ajuster. A cette fin,
#STKT_TIMEVAL_ADR peut être NULL, ce qui met à jour
#STKT_TIMEVAL2_VAR, sans effectuer un nouveau adjtime().
#Ainsi, le premier appel à adjtime() doit être :
# - adjtime(STKT_TIMEVAL_ADR, NULL)
#Puis, pour vérifier le temps qu'il reste à ajuster :
# - adjtime(NULL, STKT_TIMEVAL_ADR)
#(on peut utiliser le même STKT_TIMEVAL_ADR), ça évite
#d'en créer deux)
----| Renvoie 0 si succès, -1 sinon.
HEADER ==> #<sys/times.h>
struct tms #Structure représentant un temps écoulé dans un process
#depuis son début. Les membres renvoient des clock ticks
#clock_t exprimées selon le même nombre de clock ticks
#par seconde que times()
STKT_TMS_VAR.tms_utime #User time écoulé du process (sans ses enfants)
STKT_TMS_VAR.tms_stime #Systeme time écoulé du process (sans ses enfants)
STKT_TMS_VAR.tms_cutime #Utime + cutime écoulé des enfants s'étant achevés et
#ayant été waited
STKT_TMS_VAR.tms_cstime #Stime + cstime écoulé des enfants s'étant achevés et
#ayant été waited
times(STKT_TMS_ADR) #Enregistre le
----| Renvoie le nombre de clock ticks écoulés depuis un
| point indéterminé dans le passé.
| Le nombre de clock ticks par seconde que pour clock(),
| soit CLOCK_PER_SEC, mais d'un nombre obtenu via :
| - sysconf(_SC_CLK_TCK)
HEADER ==> #<utime.h>
struct utimbuf #Structure stockant un atime et un mtime, pour manipuler
#utime()
STKT_UTIMBUF_VAR.actime #atime, sous forme de time_t
STKT_UTIMBUF_VAR.modtime#mtime, sous forme de time_t
struct timeval #Structure pour stocker un timestamp, mais avec une
#précision à la microseconde
STKT_TIMEVAL_VAR.tv_sec #Secondes entières, sous forme de LONG_INT
STKT_TIMEVAL_VAR.tv_usec#Microsecondes, sous forme de LONG_INT
struct timespec #Comme struct timeval, mais apporte une précision à la
#nanosecondes
STKT_TIMESPEC_VAR.tv_sec#Secondes entières, sous forme de LONG_INT
STKT_TIMSPEC_VAR.tv_nsec#Nanosecondes, sous forme de LONG_INT
utime(STR, #L'atime et le mtime du fichier dont le chemin est STR
STKT_UTIMBUF_ADR) #deviennent ceux des deux membres de STKT_UTIMBUF_VAR.
#Si STKT_UTIMBUF_ADR est NULL, il s'agit de l'heure
#courante
#Dans tous les cas, la ctime est mise à jour à l'heure
#courante.
----| 0 si succès, -1 sinon
utimes(STR, #Comme utime(), sauf que le temps est stocké dans une
STKT_TIMEVAL_ARR) #STKT_TIMEVAL_ARR, de dimension 2 : le premier élément
#est l'atime, le deuxième le mtime.
HEADER ==> #<utime.h>
MACROS A DEFINIR ==> #_BSD_SOURCE
futimes(INT_VAL, #Comme utimes(), mais utilise plutôt le file descriptor
STKT_TIMEVAL_ARR) #INT_VAL
lutimes(INT_VAL, #
STKT_TIMEVAL_ARR) #Comme utimes(), mais ne déréférence pas les symlinks