linux kernel - Conversion de jiffies en milli secondes




github history (5)

Comment convertir manuellement des jiffies en millisecondes et vice versa sous Linux? Je sais que le noyau 2.6 a une fonction pour cela, mais je travaille sur 2.4 (devoirs) et bien que j'ai regardé le code, il utilise beaucoup de macro-constantes dont je n'ai aucune idée si elles sont définies en 2.4.


Answers

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

#include <unistd.h>
#include <time.h>
#include <stdio.h>

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;
 }

Comme une réponse précédente a dit, le taux auquel les augmentations de jiffies est fixé.

La méthode standard de spécification de l'heure pour une fonction qui accepte jiffies utilise la constante HZ .

C'est l'abréviation de Hertz, ou le nombre de ticks par seconde. Sur un système avec une coche de temporisation réglée sur 1ms, HZ = 1000. Certaines distributions ou architectures peuvent utiliser un autre numéro (100 était commun).

La manière standard de spécifier un nombre de jiffies pour une fonction utilise HZ , comme ceci:

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

Dans la plupart des cas, 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 */

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

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

Pour convertir l'autre façon, vous utiliseriez:

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

Vous ne devriez pas espérer mieux que la précision en millisecondes.


Les Jiffies sont codés en dur dans Linux 2.4. Vérifiez la définition de HZ , qui est définie dans le param.h spécifique à l'architecture. C'est souvent 100 Hz, ce qui est une tique chaque (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 y a des fonctions dans include/linux/time.h appelées timespec_to_jiffies et jiffies_to_timespec où vous pouvez convertir 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.



Juste avoir une ligne ajoutée à votre crontab ..

Assurez-vous que le fichier est exécutable:

chmod +x /path_to_you_file/your_file

Pour éditer le fichier crontab:

crontab -e

Ligne que vous devez ajouter:

@reboot  /path_to_you_file/your_file

C'est simple!





linux linux-kernel