Taille de variable et taille de code.

Version imprimable

23/04/2007, 17h53
proton88

Taille de variable et taille de code.
Bonjour,

Dans le cadre de l'élaboration d'un programme en C sur microcontrôleur Atmel AVR avec AvrGCC, et ayant besoin de la fonction clock(), j'ai défini dans un fichier time.h
Code:

1 2 3 4 5 6 #define CLOCKS_PER_SEC 1000 /* 1000 x 1 = 1000 ms */ typedef long clock_t; clock_t clock(); // ticks depuis le début de main()
Pas de problème... sauf qu'à 1000 par seconde, mon compteur arrive au bout en moins d'un mois et c'est une application h24.

Alors j'ai modifié le type clock_t en long long et là, à ma grande stupeur, le code est passé de 27682 à 49608 octets ! Une idée ?
23/04/2007, 17h59
souviron34

on ne se sert pas de la fonction clock pour des grandes valeurs comme ça On utilise time .

clock sert pour mesurer des deltas de temps relativement faibles.

Mais time démarre depuis le 01/01/1970 et s'arrêtera en 2037.
23/04/2007, 18h27
Emmanuel Delahaye
Citation:
Envoyé par proton88

Bonjour,

Dans le cadre de l'élaboration d'un programme en C sur microcontrôleur Atmel AVR avec AvrGCC, et ayant besoin de la fonction clock(), j'ai défini dans un fichier time.h

Code:

1 2 3 4 5 6 #define CLOCKS_PER_SEC 1000 /* 1000 x 1 = 1000 ms */ typedef long clock_t; clock_t clock(); // ticks depuis le début de main()

Pas de problème... sauf qu'à 1000 par seconde, mon compteur arrive au bout en moins d'un mois et c'est une application h24.

Alors j'ai modifié le type clock_t en long long et là, à ma grande stupeur, le code est passé de 27682 à 49608 octets ! Une idée ?
Oui. Comme tu demandes l'usage d'un long long (C99), l'éditeur de lien a probablement ajouté tout ou partie du paquet C99 à ton application qui a brutalement augmenté de taille. Mais comme dit Souviron, tu fais n'importe quoi...

clock() sert à retourner le nombre de ticks depuis la mise sous tension (en principe, un tic fait entre 1ms et 100 ms)

Pour mesurer le temps, on utilise le type time_t et on compte des secondes.

Le type exact de time_t dépend de l'implémentation. Effectivement sur les machines où il fait 32 bits, ça s'arrête en 2037 ou 38. Mais il peut très bien faire 64 bits, et dans ce cas, le soleil aura probablement explosé avant...
23/04/2007, 19h18
koala01

Salut,

Citation:

Envoyé par Emmanuel Delahaye

(snip) Mais il peut très bien faire 64 bits, et dans ce cas, le soleil aura probablement explosé avant...

En fait, notre soleil ne risque, sauf erreur, pas d'exploser...

Ce qu'il fera dans la fin de sa vie (mais on a le temps :D), c'est de se dilater jusqu'à englober la terre, avant de refroidir et de se recontracter...

Pas de super nova pour notre soleil, sa masse n'est pas suffisante :D
24/04/2007, 09h36
proton88
Merci pour ces réponses mais....

En fait, mon problème n'est pas de mesurer des durées de plusieurs jours, ce dont je n'ai pas besoin.

Mon problème est que si je fais une tempo de une seconde comme ceci:
Code:

1 2 3 4 5 6 clock_t tempo; tempo = clock() + CLOCKS_PER_SEC; /* Tempo 1 seconde */ while( clock() < tempo ) ;
... si la valeur de clock() déborde pendant la tempo et passe donc de +2000000000 à -2000000000 (je n'ai pas en tête la valeur précise :) ), ma tempo va s'arrêter avant l'heure parce que la condition sera vraie.

J'espère m'être mieux exprimé cette fois-ci.

Edit: Euh... en fait non, ce qui risque d'arriver, c'est que clock() soit positif au départ et que clock()+1000 soit négatif. Donc la durée de la tempo soit nulle - Autant pour moi. :lol:
24/04/2007, 09h47
koala01

Peut etre serait-il peut etre, tout simplement, utile d'envisager le typedef en tant que unsigned long...

Cela devrait régler le problème parce que les valeurs seraient d'office supérieures ou égales à zéro et que, de toutes manières, si on arrive à la valeur extreme possible sur un long avec clock()+CLOCKS_PER_SEC, ce sera pris en compte également ;) (avec au pire un décalage d'un tick)
24/04/2007, 09h48
fearyourself

Ou si tu veux juste attendre une seconde, pourquoi faire une attente active ?

Utilise un sleep(1).

Jc
24/04/2007, 09h57
proton88

Citation:

Envoyé par koala01

Peut etre serait-il peut etre, tout simplement, utile d'envisager le typedef en tant que unsigned long...

Cela devrait régler le problème parce que les valeurs seraient d'office supérieures ou égales à zéro et que, de toutes manières, si on arrive à la valeur extreme possible sur un long avec clock()+CLOCKS_PER_SEC, ce sera pris en compte également ;) (avec au pire un décalage d'un tick)

En fait, j'aurai le même problème si on arrive aux limites: clock() sera très grand, clock() + 1000 sera petit (inférieur à 1000) et la condition sera fausse à nouveau dès l'entrée dans la tempo...

Pour répondre à fearyourself, j'utilise clock() pour faire des tempos entre 10ms et une heure, mais mon exemple n'était là que pour illustrer mon propos. En fait, j'initialise ma variable, je gère les affaires courantes (traitement de données GPS, traitement de dialogue radio, etc...) et je passe voir ensuite si ma tempo est terminée.

Comme je le disais et comme l'a dit Emmanuel, il faut utiliser time_t et éventuellement, pour descendre à la milliseconde en VALEUR ABSOLUE, les structures timeval etc..

La fonction clock() donne le temps mesuré POUR TON PROGRAMME, pas dans l'absolu.

Voici un exemple de fonction donnant le VRAI temps absolu en secondes avec une précision à la microseconde :

Code:

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
 
#include <time.h>
#include <sys/time.h>
#ifdef LINUX
#include <unistd.h>
#endif
 
double GetClock ( void )
{
  double d ;
#ifndef LINUX
#ifdef WINDOWS
  struct timeval tval ;
  struct timezone *tz=(struct timezone *)NULL ;
  timerclear(&tval);
  if ( gettimeofday(&tval, tz) )
    {
#ifdef DEBUG
      fprintf (stderr, " CLOCK ERROR !!!");
#endif
    }
  d = ((double)(tval.tv_usec)/1000000.0) ;
  d = (double) tval.tv_sec + d ;
#else
  struct timespec cur_time, res ;
 
  if (clock_gettime(CLOCK_REALTIME, &cur_time))
    {
#ifdef DEBUG
      fprintf (stderr, " CLOCK ERROR !!!");
#endif
    }
  d = ((double)(cur_time.tv_nsec)/1000.0) / 1000000.0 ;
  d = (double) cur_time.tv_sec + d ;
#endif
#else    
  struct timeval tval ;
  struct timezone *tz=(struct timezone *)NULL ;
  timerclear(&tval);
  if ( gettimeofday(&tval, tz) )
    {
#ifdef DEBUG
      fprintf (stderr, " CLOCK ERROR !!!");
#endif
    }
  d = ((double)(tval.tv_usec)/1000000.0) ;
  d = (double) tval.tv_sec + d ;
#endif
 
  return d ;
}

Et maintenant comment l'utiliser :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
double   t_depart, t_fin, t ;
double   duree_en_millisecondes ; /* 1000 pour une seconde, 3600000 pour une heure */
 
/* Calcul temps départ */
t_depart = GetClock() ;
 
/* Calcul temps fin */
t_fin = t_depart + (duree_en_millisecondes/1000.0) ;
 
 
while( (t=GetClock()) < t_fin )
  {
      ............
  }