Clock_gettime nanosecondes calcul

ref: linux clock_gettime

J'ai trouvé une formule qui fonctionne bien pour obtenir le temps de traitement, mais il y a quelque chose que je ne comprends pas.
Voir le résultat ci-dessous.

Les 2 premières lignes, c'est juste pour montrer la forumla dans leurs colonnes respectives.

Je suis le seul à en montrant 3 les résultats d'une course rapide.

La partie intéressante est dans la dernière ligne, pourquoi est - 5551 - 999896062 nanosecondes = 18446744072709661105?

Pourquoi est - 18446744072709661105+1/1E9 = 0.000109?

Je pense qu'il y a certains de conversion de données en cours qui affecte les résultats?

xx:      | t1.tv_sec |   | t1.tv_nsec |          | t2.tv_sec |   | t2.tv_nsec 
xx:      t2-t1(sec)      t2-t1(nsec)         (t2-t1(sec))+(t2-t1(nsec))/1E9

52291:   | 30437 |   | 999649886 |       | 30437 |   | 999759331 
52291:   0   109445          0.000109

52292:   | 30437 |   | 999772970 |       | 30437 |   | 999882416 
52292:   0   109446          0.000109

52293:   | 30437 |   | 999896062 |       | 30438 |   | 5551 
52293:   1   18446744072709661105        0.000109

code source:

int main() {
    struct timespec t1, t2;

    int i = 0;
    while(1) {
        clock_gettime(CLOCK_MONOTONIC, &t1);
            for(int j=0;j<25000;j++) { };
        clock_gettime(CLOCK_MONOTONIC, &t2);
        printf("%d: \t | %llu | \t | %lu | \t\t | %llu | \t | %lu \n", i, (unsigned long long) t1.tv_sec, t1.tv_nsec, (unsigned long long) t2.tv_sec, t2.tv_nsec);
        printf("%d: \t %llu \t %lu \t\t %lf\n", i, (unsigned long long) t2.tv_sec - t1.tv_sec, t2.tv_nsec - t1.tv_nsec, (t2.tv_sec - t1.tv_sec)+(t2.tv_nsec - t1.tv_nsec)/1E9);
        if ((t2.tv_sec - t1.tv_sec) == 1) break;
        i++;
    }
    return 0;
}
Pourquoi ne pas vous convertir le résultat de clock_gettime() 64-bit nombre de nanosecondes? Rend la vie tellement plus facile.

OriginalL'auteur resting | 2012-12-19

  1. 4

    Parce que 5551 - 999896062 est négative, la valeur, stockée dans une variable temporaire de type long, mais interprété par printf "unsigned long" en raison de la %lu indicateur de conversion.

    Noter que le tv_nsec champ struct timespec est de type long, pas unsigned long. De même, sur Linux et autres systèmes Unix time_t est un typedef pour un entier signé de type. Afin de se débarrasser de tous les unsigned des choses dans votre code.

    Btw, une façon de soustraire deux timespec cas est

    
timespec diff(timespec start, timespec end)
{
        timespec temp;
        if ((end.tv_nsec - start.tv_nsec) < 0) 
        {
                temp.tv_sec = end.tv_sec - start.tv_sec - 1;
                temp.tv_nsec = 1000000000 + end.tv_nsec - start.tv_nsec;
        } 
        else 
        {
                temp.tv_sec = end.tv_sec - start.tv_sec;
                temp.tv_nsec = end.tv_nsec - start.tv_nsec;
        }
        return temp;
}
    Je pense que votre solution est un C++ solution? Mais de toute façon, vous avez raison au sujet de la unsigned long format d'impression. Changé, et il a renvoyé les bons numéros de laquelle j'ai pu alors vérifier les résultats manuellement. Merci. Juste par curiosité, comment vérifier une précision de l'ordre de la nanoseconde, car il n'y a pas de support physique à mesurer. Et comment le CLOCK_MONOTONIC travail? De lire qu'il représente à l'époque de fois depuis les années 1970. Mais comment peut-on vérifier sa précision de l'ordre de la nanoseconde? Serait-il le même sur toutes les machines?
    Bon, je copie-collé du code C++ j'avais traîner. Mais si vous changez de "timespec" à "struct timespec" il faut travailler dans la plaine C ainsi.
    CLOCK_MONOTONIC représente le temps depuis quelques temps indéterminé dans le passé (par exemple, sur Linux zéro est défini pour un certain temps avant que le temps de démarrage du système), et est monotone, c'est à dire ne pas changer, par exemple si l'horloge du système est modifié. CLOCK_REALTIME représente le temps depuis l'époque.
    Pourquoi serait-fin - début négative?
    tv_nsec est une fraction de seconde, c'est nanosecondes depuis la seconde dans le tv_sec champ.

    OriginalL'auteur janneb