Conversion de jiffies en milli secondes

Comment convertir manuellement les jiffies en millisecondes et inversement sous Linux? Je sais que le kernel 2.6 a une fonction pour cela, mais je travaille sur 2.4 (devoirs) et même si j’ai regardé le code, il utilise beaucoup de constantes de macro que je n’ai aucune idée si elles sont définies dans 2.4.

Comme indiqué précédemment, le taux d’incrémentation des jiffies est fixe.

La méthode standard de spécification du temps pour une fonction qui accepte les jiffies consiste à utiliser la constante HZ .

C’est l’abréviation de Hertz ou le nombre de ticks par seconde. Sur un système avec une temporisation cochée à 1 ms, HZ = 1000. Certaines dissortingbutions ou architectures peuvent utiliser un autre numéro (100 étant commun).

La méthode standard pour spécifier un nombre de jiffies pour une fonction consiste à utiliser HZ , comme ceci:

 schedule_timeout(HZ / 10); /* Timeout after 1/10 second */ 

Dans la plupart des cas simples, cela fonctionne très bien.

 2*HZ /* 2 seconds in jiffies */ HZ /* 1 second in jiffies */ foo * HZ /* foo seconds in jiffies */ HZ/10 /* 100 milliseconds in jiffies */ HZ/100 /* 10 milliseconds in jiffies */ bar*HZ/1000 /* bar milliseconds in jiffies */ 

Ces deux derniers problèmes ont toutefois un petit problème, car sur un système avec une temporisation de 10 ms, HZ/100 vaut 1 et la précision commence à en souffrir. Vous pouvez obtenir un délai compris entre 0,0001 et 1,999 timer (0-2 ms, essentiellement). Si vous avez essayé d’utiliser HZ/200 sur un système à 10 ms, la division entière vous donne 0 jiffies!

Donc, la règle de base est, soyez très prudent en utilisant HZ pour les valeurs minuscules (celles qui approchent 1 jiffie).

Pour convertir dans l’autre sens, vous utiliseriez:

 jiffies / HZ /* jiffies to seconds */ jiffies * 1000 / HZ /* jiffies to milliseconds */ 

Vous ne devez rien attendre de mieux que la précision à la milliseconde.

Les jiffies sont codés en dur sous Linux 2.4. Vérifiez la définition de HZ , qui est définie dans le param.h spécifique à l’architecture. Il est souvent de 100 Hz, ce qui correspond à un tick (1 sec / 100 ticks * 1000 ms / sec) 10 ms.

Cela est vrai pour i386 et HZ est défini dans include/asm-i386/param.h .

Il existe des fonctions dans include/linux/time.h appelées timespec_to_jiffies et jiffies_to_timespec où vous pouvez effectuer des conversions entre une struct timespec et des jiffies :

  #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1) static __inline__ unsigned long timespec_to_jiffies(struct timespec *value) { unsigned long sec = value->tv_sec; long nsec = value->tv_nsec; if (sec >= (MAX_JIFFY_OFFSET / HZ)) return MAX_JIFFY_OFFSET; nsec += 1000000000L / HZ - 1; nsec /= 1000000000L / HZ; return HZ * sec + nsec; } static __inline__ void jiffies_to_timespec(unsigned long jiffies, struct timespec *value) { value->tv_nsec = (jiffies % HZ) * (1000000000L / HZ); value->tv_sec = jiffies / HZ; } 

Note: J’ai vérifié cette information dans la version 2.4.22.

J’ai trouvé cet exemple de code sur kernelnewbies . Assurez-vous de -lrt lien avec -lrt

 #include  #include  #include  int main() { struct timespec res; double resolution; printf("UserHZ %ld\n", sysconf(_SC_CLK_TCK)); clock_getres(CLOCK_REALTIME, &res); resolution = res.tv_sec + (((double)res.tv_nsec)/1.0e9); printf("SystemHZ %ld\n", (unsigned long)(1/resolution + 0.5)); return 0; } 

Réponse à # 3875801 peut également être révélateur

Pour obtenir la valeur USER_HZ (voir les commentaires sous la réponse acceptée) en utilisant l’interface de ligne de commande:

 getconf CLK_TCK