Obtenir un timestamp en C en microsecondes?

Comment puis-je obtenir un microsecondes horodatage dans le C?

Je suis en train de faire:

struct timeval tv;
gettimeofday(&tv,NULL);
return tv.tv_usec;

Mais ceci renvoie à des bêtises de valeur que si je reçois deux horodateurs, la deuxième peut être plus grande ou plus petite que la première (seconde toujours plus grand). Serait-il possible de convertir la magie entier retourné par gettimeofday à un nombre normal, ce qui peut réellement être travaillé?

  • tv_usec n'est pas "au courant de temps en microsecondes" mais le "courant de temps en microsecondes modulo 10^6".
  • Essayez de POSIX clock_gettime().
  • Comment puis-je convertir en "normal" nombre?
  • Brooks: eh bien.. "normal", les nombres ont une mauvaise habbit d'avoir de gamme, donc il y aura toujours être une valeur pour laquelle il n'y a pas de plus grande valeur. Je pense que vous devriez revoir votre alrogithm. Essayez (sec2 - sec1)*1000000 + (usec2 - usec1). Ou, mieux, pour éviter les débordement possible pour les secondes, si vous savez que la période est inférieure à une seconde, lors de la seconde valeur est plus petite juste ajouter 1 000 000 pour elle.
  • J'ai juste besoin d'une microseconde d'horodatage pour calculer le défilement à inertie. J'ai besoin de quelque chose comme du temps (), mais pour une fraction de seconde.
  • liées - stackoverflow.com/questions/361363/...

InformationsquelleAutor Kristina Brooks | 2011-04-29
  1. 46

    Vous avez besoin d'ajouter, dans les secondes, trop:

    unsigned long time_in_micros = 1000000 * tv.tv_sec + tv.tv_usec;

    Notez que cela ne durera environ 232/106 =~ 4295 secondes, soit environ 71 minutes (sur un système 32-bits).

    • Utiliser un entier de 64 bits pour stocker des microsecondes, sûrement
    • PROBLÈME AVEC la SOLUTION: Parce que vous ne commencez pas avec tv_sec à zéro, time_in_micros pourrait roll-over à TOUT moment! Il n'y a pas besoin de se déplacer 64 bits de temps, que ce soit comme un seul un uint64_t ou deux valeurs de 32 bits. À tout le moins, lorsque vous démarrez le moment, enregistrez le tv_sec valeur de l'heure de début et de le soustraire de toutes les valeurs de temps.
    • Laisser la valeur à rouler dans système 32 bits n'est pas que mauvais, si vous savez ce que vous faites. Vous pouvez toujours obtenir sain d'esprit des valeurs de la base de calcul de current_microseconds-start_time si l'intervalle n'est jamais supérieure à 71 minutes dans votre mise en œuvre.
    InformationsquelleAutor unwind
  2. 18

    Vous avez deux choix pour l'obtention d'une microseconde d'horodatage. Le premier (et meilleur) choix, est d'utiliser le timeval taper directement:

    struct timeval GetTimeStamp() {
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return tv;
}

    La deuxième, et pour moi, moins souhaitable, le choix est de construire un uint64_t d'un timeval:

    uint64_t GetTimeStamp() {
    struct timeval tv;
    gettimeofday(&tv,NULL);
    return tv.tv_sec*(uint64_t)1000000+tv.tv_usec;
}
    • pourquoi (uint64_t)1000000 au lieu de 1000000ull?
    • Aucune raison valable ne vient à l'esprit.
    • Canard, pour moi (a moins programmeur expérimenté que toi), (uint64_t)1000000 est même plus lisible que 1000000ull. Maintenant que je les ai vu ensemble, le second fait tout comme beaucoup de sens, mais je l'aurais reconnu le premier même comme un beaucoup plus jeune programmeur, alors que le dernier aurait exigé que je cherche à vérifier ce qu'il signifie.
    • ull ne précise pas exactement le même nombre de bits sur tous les systèmes. uintXX_t est bon de sécurité que vous obtiendrez exactement ce que vous voulez.
    InformationsquelleAutor Robᵩ
  3. 8

    struct timeval contient deux composants, de la deuxième et de la microseconde. Un timestamp avec une précision est représenté sous forme de secondes depuis l'epoch stockées dans le tv_sec champ et que les fractions de microsecondes dans tv_usec. Ainsi, vous ne peut pas simplement ignorer tv_sec et attendre sensible des résultats.

    Si vous utilisez Linux ou *BSD, vous pouvez utiliser timersub() pour soustraire deux struct timeval valeurs, qui pourrait être ce que vous voulez.

    InformationsquelleAutor janneb
  4. 2

    Mais cela renvoie des bêtises valeur
    que si je reçois deux horodateurs, l'
    deuxième peut être plus petite ou plus grande
    que la première (seconde
    toujours plus grand).

    Ce qui vous fait penser à qui? La valeur est probablement OK. C'est la même situation qu'avec les secondes et les minutes – lorsque vous mesurez le temps en minutes et en secondes, le nombre de secondes repasse à zéro quand il arrive à soixante.

    Pour convertir la valeur renvoyée dans un “linéaire” le nombre on pourrait multiplier le nombre de secondes et ajouter quelques microsecondes. Mais si je compte bien, l'un an est d'environ 1e6*60*60*24*360 µs et cela signifie que vous aurez besoin de plus de 32 bits pour stocker le résultat:

    $ perl -E '$_=1e6*60*60*24*360; say int log($_)/log(2)'
44

    Qui est probablement l'une des raisons pour fractionner l'original de la valeur retournée en deux morceaux.

    InformationsquelleAutor zoul
  5. 2

    timespec_get de C11 les retours jusqu'à la nanoseconde, arrondie à la résolution de la mise en œuvre.

    #include <time.h>
struct timespec ts;
timespec_get(&ts, TIME_UTC);
struct timespec {
    time_t   tv_sec;        /* seconds */
    long     tv_nsec;       /* nanoseconds */
};

    Plus de détails ici: https://stackoverflow.com/a/36095407/895245

    InformationsquelleAutor Ciro Santilli 新疆改造中心996ICU六四事件
  6. 0

    Nous avons d'abord besoin de savoir sur la gamme de microsecondes c'est à dire 000_000 à 999_999 (1000000 microsecondes est égal à 1second). tv.tv_usec sera de retour la valeur de 0 à 999999 pas 000000 à 999999 donc, lors de l'utilisation de secondes que l'on pourrait avoir de 2,1 secondes au lieu de 2.000001 secondes parce que quand seulement parler de tv_usec 000001 est essentiellement 1.
    Son meilleur si vous insérez 

    if(tv.tv_usec<10)
{
 printf("00000");
} 
else if(tv.tv_usec<100&&tv.tv_usec>9)//i.e. 2digits
{
 printf("0000");
}

    et ainsi de suite...

    InformationsquelleAutor Osaid
  7. 0

    utiliser un unsigned long long (c'est à dire une version 64 bits de l'unité) pour représenter le temps de système:

    typedef unsigned long long u64;

u64 u64useconds;
struct timeval tv;

gettimeofday(&tv,NULL);
u64useconds = (1000000*tv.tv_sec) + tv.tv_usec;
    InformationsquelleAutor user6269400