j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez
vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api
plus precise.
Une autre quoi ? Une autre fonction, ayant une meilleure résolution ?
En C++ standard, je ne crois pas. Sous *nix, il y a gettimeoftheday() je crois ; sous Windows, il y a plusieurs possibilités : timeGetTime(), GetTickCount(), etc.
On Fri, 9 Sep 2005 21:02:48 +0200, pasde.bcausse.spam@wanadoo.fr
(Bruno Causse):
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez
vous, plusieurs secondes sur une minute :-(
De quoi parles-tu exactement ? De la fonction "time_t time (time_t*)",
c'est ça ?
Cette fonction a une précision égale à celle de ton PC.
La résolution, par contre, est de une seconde.
C'est-à-dire que l'erreur du code suivant ne peut pas être supérieure
à une seconde, quelle que soit la durée totale :
Une autre quoi ? Une autre fonction, ayant une meilleure résolution ?
En C++ standard, je ne crois pas. Sous *nix, il y a gettimeoftheday()
je crois ; sous Windows, il y a plusieurs possibilités :
timeGetTime(), GetTickCount(), etc.
Une autre quoi ? Une autre fonction, ayant une meilleure résolution ?
En C++ standard, je ne crois pas. Sous *nix, il y a gettimeoftheday() je crois ; sous Windows, il y a plusieurs possibilités : timeGetTime(), GetTickCount(), etc.
Cyrille
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
--
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez
vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api
plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante
du système, mais généralement inférieure à la seconde (1/100eme de
secondes sous Linux). Le nombre retourné doit-être divisé par
CLOCKS_PER_SEC pour obtenir des secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais
tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
--
bernard tatin
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Soit t0 = time(0) et t1 = time(0). time(0) renvoie le nombre de secondes
depuis le 01/01/1970. Donc t0 et t1 sont précis à 1 seconde près. Cela signifie donc que t1 - t0 est précis à deux secondes près, quelque soit la valeur de l'intervalle. Si la dérive sur une minute est supérieure à deux secondes, alors il y a un problème soit avec l'horloge de la machine, soit dans la méthode de mesure de la dérive. Il est aussi possible que la machine soit vraiment surchargée par des tâches de fond ou qu'elle swappe comme un PC sous Windows et là, la mesure des intervalle et délicate, quelque soit la méthode.
La fonction ctime renvoie un pointeur sur une chaîne de caractère. Cette chaîne est gérée par la bibliothèque. Voici un exemple de programme qui foire :
time_t t0 = time(0); char *strT0 = ctime(&t0); // du code qui met plus d'une seconde à s'exécuter // par exemple sleep(5); time_t t1 = time(0); char *strT1 = ctime(&t1); printf ("- %s- %s", strT0, strT1);
affichera par exemple :
- Sat Sep 10 18:01:58 2005 - Sat Sep 10 18:01:58 2005
Alors que :
time_t t0 = time(0); char *strT0 = ctime(&t0); char buffer0[32]; strcpy(buffer0, strT0); // du code qui met plus d'une seconde à s'exécuter // par exemple sleep(5); time_t t1 = time(0); char *strT1 = ctime(&t1); char buffer1[32]; strcpy(buffer1, strT1); printf ("- %s- %s", buffer0, buffer1);
affichera : - Sat Sep 10 18:05:25 2005 - Sat Sep 10 18:05:30 2005
Bernard
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez
vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api
plus precise.
merci
Soit t0 = time(0) et t1 = time(0). time(0) renvoie le nombre de secondes
depuis le 01/01/1970. Donc t0 et t1 sont précis à 1 seconde près. Cela
signifie donc que t1 - t0 est précis à deux secondes près, quelque soit
la valeur de l'intervalle. Si la dérive sur une minute est supérieure à
deux secondes, alors il y a un problème soit avec l'horloge de la
machine, soit dans la méthode de mesure de la dérive. Il est aussi
possible que la machine soit vraiment surchargée par des tâches de fond
ou qu'elle swappe comme un PC sous Windows et là, la mesure des
intervalle et délicate, quelque soit la méthode.
La fonction ctime renvoie un pointeur sur une chaîne de caractère. Cette
chaîne est gérée par la bibliothèque. Voici un exemple de programme qui
foire :
time_t t0 = time(0);
char *strT0 = ctime(&t0);
// du code qui met plus d'une seconde à s'exécuter
// par exemple
sleep(5);
time_t t1 = time(0);
char *strT1 = ctime(&t1);
printf ("- %s- %s", strT0, strT1);
affichera par exemple :
- Sat Sep 10 18:01:58 2005
- Sat Sep 10 18:01:58 2005
Alors que :
time_t t0 = time(0);
char *strT0 = ctime(&t0);
char buffer0[32];
strcpy(buffer0, strT0);
// du code qui met plus d'une seconde à s'exécuter
// par exemple
sleep(5);
time_t t1 = time(0);
char *strT1 = ctime(&t1);
char buffer1[32];
strcpy(buffer1, strT1);
printf ("- %s- %s", buffer0, buffer1);
affichera :
- Sat Sep 10 18:05:25 2005
- Sat Sep 10 18:05:30 2005
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Soit t0 = time(0) et t1 = time(0). time(0) renvoie le nombre de secondes
depuis le 01/01/1970. Donc t0 et t1 sont précis à 1 seconde près. Cela signifie donc que t1 - t0 est précis à deux secondes près, quelque soit la valeur de l'intervalle. Si la dérive sur une minute est supérieure à deux secondes, alors il y a un problème soit avec l'horloge de la machine, soit dans la méthode de mesure de la dérive. Il est aussi possible que la machine soit vraiment surchargée par des tâches de fond ou qu'elle swappe comme un PC sous Windows et là, la mesure des intervalle et délicate, quelque soit la méthode.
La fonction ctime renvoie un pointeur sur une chaîne de caractère. Cette chaîne est gérée par la bibliothèque. Voici un exemple de programme qui foire :
time_t t0 = time(0); char *strT0 = ctime(&t0); // du code qui met plus d'une seconde à s'exécuter // par exemple sleep(5); time_t t1 = time(0); char *strT1 = ctime(&t1); printf ("- %s- %s", strT0, strT1);
affichera par exemple :
- Sat Sep 10 18:01:58 2005 - Sat Sep 10 18:01:58 2005
Alors que :
time_t t0 = time(0); char *strT0 = ctime(&t0); char buffer0[32]; strcpy(buffer0, strT0); // du code qui met plus d'une seconde à s'exécuter // par exemple sleep(5); time_t t1 = time(0); char *strT1 = ctime(&t1); char buffer1[32]; strcpy(buffer1, strT1); printf ("- %s- %s", buffer0, buffer1);
affichera : - Sat Sep 10 18:05:25 2005 - Sat Sep 10 18:05:30 2005
Bernard
Fabien LE LEZ
On Sat, 10 Sep 2005 18:08:16 +0200, bernard tatin :
Même sur un exemple traitant d'un sujet totalement différent, c'est criminel d'afficher un tel code. Pire, je subodore que tu ne renâclerais pas à l'idée de considérer ça comme du C++, et de l'inclure dans ton propre code.
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je tiquerais -- ne serait-ce que par l'usage de la "magic value" 32. (D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.) De même, le strcpy me paraît un peu limite -- strncpy me semble plus fiable. Enfin, tu écris deux fois presque le même code, il serait de bon ton d'en faire une fonction.
Mais nous sommes sur fr.comp.lang.c++. C'est-à-dire, un forum sur lequel il est vivement conseillé d'utiliser les avantages de base du C++.
Même sur un exemple traitant d'un sujet totalement différent, c'est
criminel d'afficher un tel code. Pire, je subodore que tu ne
renâclerais pas à l'idée de considérer ça comme du C++, et de
l'inclure dans ton propre code.
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je
tiquerais -- ne serait-ce que par l'usage de la "magic value" 32.
(D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.)
De même, le strcpy me paraît un peu limite -- strncpy me semble plus
fiable.
Enfin, tu écris deux fois presque le même code, il serait de bon ton
d'en faire une fonction.
Mais nous sommes sur fr.comp.lang.c++. C'est-à-dire, un forum sur
lequel il est vivement conseillé d'utiliser les avantages de base du
C++.
Même sur un exemple traitant d'un sujet totalement différent, c'est criminel d'afficher un tel code. Pire, je subodore que tu ne renâclerais pas à l'idée de considérer ça comme du C++, et de l'inclure dans ton propre code.
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je tiquerais -- ne serait-ce que par l'usage de la "magic value" 32. (D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.) De même, le strcpy me paraît un peu limite -- strncpy me semble plus fiable. Enfin, tu écris deux fois presque le même code, il serait de bon ton d'en faire une fonction.
Mais nous sommes sur fr.comp.lang.c++. C'est-à-dire, un forum sur lequel il est vivement conseillé d'utiliser les avantages de base du C++.
On Sat, 10 Sep 2005 18:23:03 +0200, Fabien LE LEZ :
time_t heure= time (0); return ctime (&t0);
"return ctime (heure);" bien sûr. Désolé.
Richard Delorme
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je tiquerais -- ne serait-ce que par l'usage de la "magic value" 32. (D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.) De même, le strcpy me paraît un peu limite -- strncpy me semble plus fiable.
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
-- Richard
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je
tiquerais -- ne serait-ce que par l'usage de la "magic value" 32.
(D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.)
De même, le strcpy me paraît un peu limite -- strncpy me semble plus
fiable.
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Admettons un instant qu'on soit sur fr.comp.lang.c. Déjà là, je tiquerais -- ne serait-ce que par l'usage de la "magic value" 32. (D'où il sort, ce 32, d'ailleurs ? Ma doc indique 26.) De même, le strcpy me paraît un peu limite -- strncpy me semble plus fiable.
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
-- Richard
Fabien LE LEZ
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme :
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ? Que préconisent-ils ?
Note : je crois bien n'avoir jamais écrit un programme correct en C utilisant des chaînes de caractères. Pour la bonne raison qu'au moment où ma compréhension du problème était devenue suffisante, j'avais découvert le C++...
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme
<abulmo@nospam.fr>:
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ? Que préconisent-ils ?
Note : je crois bien n'avoir jamais écrit un programme correct en C
utilisant des chaînes de caractères. Pour la bonne raison qu'au moment
où ma compréhension du problème était devenue suffisante, j'avais
découvert le C++...
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme :
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ? Que préconisent-ils ?
Note : je crois bien n'avoir jamais écrit un programme correct en C utilisant des chaînes de caractères. Pour la bonne raison qu'au moment où ma compréhension du problème était devenue suffisante, j'avais découvert le C++...
Richard Delorme
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme :
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ?
Parce qu'il ne met quasiment jamais le bon nombre de ' ' terminal, soit pas assez (il ne termine pas la chaine par un ' ', et se promener en C avec de telle chaine est très dangereux), soit trop (remplit le reste de la chaine avec des ' ', ce qui pose des problèmes de performance).
Que préconisent-ils ?
Une variante non standard, strlcpy :
http://www.courtesan.com/todd/papers/strlcpy.html
Note : je crois bien n'avoir jamais écrit un programme correct en C utilisant des chaînes de caractères. Pour la bonne raison qu'au moment où ma compréhension du problème était devenue suffisante, j'avais découvert le C++...
Je suis bien d'accord, d'ailleurs un défaut du C++, c'est qu'il subsiste des traces des chaines C par endroit (p.ex. dans main(int argc, char **argv)).
-- Richard
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme
<abulmo@nospam.fr>:
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ?
Parce qu'il ne met quasiment jamais le bon nombre de ' ' terminal, soit
pas assez (il ne termine pas la chaine par un ' ', et se promener en C
avec de telle chaine est très dangereux), soit trop (remplit le reste de
la chaine avec des ' ', ce qui pose des problèmes de performance).
Que préconisent-ils ?
Une variante non standard, strlcpy :
http://www.courtesan.com/todd/papers/strlcpy.html
Note : je crois bien n'avoir jamais écrit un programme correct en C
utilisant des chaînes de caractères. Pour la bonne raison qu'au moment
où ma compréhension du problème était devenue suffisante, j'avais
découvert le C++...
Je suis bien d'accord, d'ailleurs un défaut du C++, c'est qu'il subsiste
des traces des chaines C par endroit (p.ex. dans main(int argc, char
**argv)).
On Sat, 10 Sep 2005 19:01:04 +0200, Richard Delorme :
Sur fr.comp.lang.c, on se fait aussi lyncher quand on utilise strncpy...
Tiens, pourquoi donc ?
Parce qu'il ne met quasiment jamais le bon nombre de ' ' terminal, soit pas assez (il ne termine pas la chaine par un ' ', et se promener en C avec de telle chaine est très dangereux), soit trop (remplit le reste de la chaine avec des ' ', ce qui pose des problèmes de performance).
Que préconisent-ils ?
Une variante non standard, strlcpy :
http://www.courtesan.com/todd/papers/strlcpy.html
Note : je crois bien n'avoir jamais écrit un programme correct en C utilisant des chaînes de caractères. Pour la bonne raison qu'au moment où ma compréhension du problème était devenue suffisante, j'avais découvert le C++...
Je suis bien d'accord, d'ailleurs un défaut du C++, c'est qu'il subsiste des traces des chaines C par endroit (p.ex. dans main(int argc, char **argv)).
-- Richard
Patrick 'Zener' Brunet
Bonjour.
Je réponds à Cyrille
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte ! clock() en principe rend un temps en ticks que le système a consacré à votre process, ce qui exclut donc le temps qu'il a consacré à toute autre chose (les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une reflet du temps CPU consommé par le process, pas d'une durée absolue.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une calculette : on l'a mais elle n'est pas significative), j'ai dû passer par les API propriétaire du système.
Il y a plusieurs manières de procéder : - déjà en principe ça passe par une structure plutôt que par l'utopie de tout fourrer dans une seule variable (pas un double par pitié !), - ladite structure peut être remplie en une ou plusieurs fois (plusieurs appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin dans la journée) puis la globale (date) puis retester la plus fine et corriger la date si on a eu la mauvaise idée de passer minuit entre le premier et le second appel :-D
Cordialement,
-- /*************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe ***************************************/
Bonjour.
Je réponds à Cyrille <cyrille@frsf.invalid>
bonsoir,
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez
vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre
api plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution
dépendante du système, mais généralement inférieure à la seconde
(1/100eme de secondes sous Linux). Le nombre retourné doit-être
divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte !
clock() en principe rend un temps en ticks que le système a consacré à votre
process, ce qui exclut donc le temps qu'il a consacré à toute autre chose
(les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une
reflet du temps CPU consommé par le process, pas d'une durée absolue.
Si tu as une dérivation de plusieurs secondes sur une minute, je
serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde
est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une
calculette : on l'a mais elle n'est pas significative), j'ai dû passer par
les API propriétaire du système.
Il y a plusieurs manières de procéder :
- déjà en principe ça passe par une structure plutôt que par l'utopie de
tout fourrer dans une seule variable (pas un double par pitié !),
- ladite structure peut être remplie en une ou plusieurs fois (plusieurs
appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin
dans la journée) puis la globale (date) puis retester la plus fine et
corriger la date si on a eu la mauvaise idée de passer minuit entre le
premier et le second appel :-D
Cordialement,
--
/***************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
***************************************/
j'utilise <ctime> dans mon prog mais la precision n'est pas au rendez vous, plusieurs secondes sur une minute :-( n'y a t'il pas une autre api plus precise.
merci
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte ! clock() en principe rend un temps en ticks que le système a consacré à votre process, ce qui exclut donc le temps qu'il a consacré à toute autre chose (les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une reflet du temps CPU consommé par le process, pas d'une durée absolue.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une calculette : on l'a mais elle n'est pas significative), j'ai dû passer par les API propriétaire du système.
Il y a plusieurs manières de procéder : - déjà en principe ça passe par une structure plutôt que par l'utopie de tout fourrer dans une seule variable (pas un double par pitié !), - ladite structure peut être remplie en une ou plusieurs fois (plusieurs appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin dans la journée) puis la globale (date) puis retester la plus fine et corriger la date si on a eu la mauvaise idée de passer minuit entre le premier et le second appel :-D
Cordialement,
-- /*************************************** * Patrick BRUNET * E-mail: lien sur http://zener131.free.fr/ContactMe ***************************************/
Cyrille
Bonjour.
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte ! clock() en principe rend un temps en ticks que le système a consacré à votre process, ce qui exclut donc le temps qu'il a consacré à toute autre chose (les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une reflet du temps CPU consommé par le process, pas d'une durée absolue.
"The function returns the number of clock ticks of elapsed processor time, counting from a time related to program startup". Bon, je n'avais pas compris ça comme ça, mais si vous le dites, j'ai pas le temps de vérifier. :)
Un autre problème de clock(), c'est l'overflow. Sur une machine 32-bits où CLOCKS_PER_SEC est égal à 1 million (valeur sur Posix), il revient à zéro après 71 minutes et 34 secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une calculette : on l'a mais elle n'est pas significative), j'ai dû passer par les API propriétaire du système.
Il y a plusieurs manières de procéder : - déjà en principe ça passe par une structure plutôt que par l'utopie de tout fourrer dans une seule variable (pas un double par pitié !), - ladite structure peut être remplie en une ou plusieurs fois (plusieurs appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin dans la journée) puis la globale (date) puis retester la plus fine et corriger la date si on a eu la mauvaise idée de passer minuit entre le premier et le second appel :-D
Plus bas niveau encore que le système, un bout de code assembleur peut faire l'affaire pour avoir la meilleure précision possible. J'utilise couramment l'instruction "rdtsc" sur les Pentium pour avoir le nombre de cycles CPU écoulés dans un entier à 64 bits (mais je suppose que comme la question d'origine était cross-postée sur un forum mac, c'est HS ici, et comme c'est de l'assembleur c'est encore plus HS sur fclc++).
-- Cyrille
Bonjour.
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution
dépendante du système, mais généralement inférieure à la seconde
(1/100eme de secondes sous Linux). Le nombre retourné doit-être
divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte !
clock() en principe rend un temps en ticks que le système a consacré à votre
process, ce qui exclut donc le temps qu'il a consacré à toute autre chose
(les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une
reflet du temps CPU consommé par le process, pas d'une durée absolue.
"The function returns the number of clock ticks of elapsed processor
time, counting from a time related to program startup". Bon, je n'avais
pas compris ça comme ça, mais si vous le dites, j'ai pas le temps de
vérifier. :)
Un autre problème de clock(), c'est l'overflow. Sur une machine 32-bits
où CLOCKS_PER_SEC est égal à 1 million (valeur sur Posix), il revient à
zéro après 71 minutes et 34 secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je
serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde
est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une
calculette : on l'a mais elle n'est pas significative), j'ai dû passer par
les API propriétaire du système.
Il y a plusieurs manières de procéder :
- déjà en principe ça passe par une structure plutôt que par l'utopie de
tout fourrer dans une seule variable (pas un double par pitié !),
- ladite structure peut être remplie en une ou plusieurs fois (plusieurs
appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin
dans la journée) puis la globale (date) puis retester la plus fine et
corriger la date si on a eu la mauvaise idée de passer minuit entre le
premier et le second appel :-D
Plus bas niveau encore que le système, un bout de code assembleur peut
faire l'affaire pour avoir la meilleure précision possible. J'utilise
couramment l'instruction "rdtsc" sur les Pentium pour avoir le nombre de
cycles CPU écoulés dans un entier à 64 bits (mais je suppose que comme
la question d'origine était cross-postée sur un forum mac, c'est HS ici,
et comme c'est de l'assembleur c'est encore plus HS sur fclc++).
Dans <ctime>, il y a 'clock_t clock()', qui a une résolution dépendante du système, mais généralement inférieure à la seconde (1/100eme de secondes sous Linux). Le nombre retourné doit-être divisé par CLOCKS_PER_SEC pour obtenir des secondes.
Alerte ! clock() en principe rend un temps en ticks que le système a consacré à votre process, ce qui exclut donc le temps qu'il a consacré à toute autre chose (les sleeps, les délais I/O, les autres processes).
Avec la valeur du tick on obtient un équivalent en secondes, mais c'est une reflet du temps CPU consommé par le process, pas d'une durée absolue.
"The function returns the number of clock ticks of elapsed processor time, counting from a time related to program startup". Bon, je n'avais pas compris ça comme ça, mais si vous le dites, j'ai pas le temps de vérifier. :)
Un autre problème de clock(), c'est l'overflow. Sur une machine 32-bits où CLOCKS_PER_SEC est égal à 1 million (valeur sur Posix), il revient à zéro après 71 minutes et 34 secondes.
Si tu as une dérivation de plusieurs secondes sur une minute, je serais tenté de dire que ton ordinateur a un problème.
Si tu veux des API plus précises, ça dépend de ton système.
Effectivement, lorsque j'ai voulu atteindre la milliseconde (la microseconde est théoriquement possible, mais AMHA c'est comme la 10ème décimale sur une calculette : on l'a mais elle n'est pas significative), j'ai dû passer par les API propriétaire du système.
Il y a plusieurs manières de procéder : - déjà en principe ça passe par une structure plutôt que par l'utopie de tout fourrer dans une seule variable (pas un double par pitié !), - ladite structure peut être remplie en une ou plusieurs fois (plusieurs appels d'API), ce qui peut conduire à commencer par la plus fine (temps fin dans la journée) puis la globale (date) puis retester la plus fine et corriger la date si on a eu la mauvaise idée de passer minuit entre le premier et le second appel :-D
Plus bas niveau encore que le système, un bout de code assembleur peut faire l'affaire pour avoir la meilleure précision possible. J'utilise couramment l'instruction "rdtsc" sur les Pentium pour avoir le nombre de cycles CPU écoulés dans un entier à 64 bits (mais je suppose que comme la question d'origine était cross-postée sur un forum mac, c'est HS ici, et comme c'est de l'assembleur c'est encore plus HS sur fclc++).
