clock_gettime alternative dans Mac OS X

En effet, il ne semble pas être mis en œuvre pour macOS avant de la Sierra 10.12. Vous pouvez regarder ce l'entrée de blog, mais cela ne semble pas être plus disponible. L'idée principale est dans l'extrait de code suivant:

#include <mach/mach_time.h>
#define ORWL_NANO (+1.0E-9)
#define ORWL_GIGA UINT64_C(1000000000)

static double orwl_timebase = 0.0;
static uint64_t orwl_timestart = 0;

struct timespec orwl_gettime(void) {
  //be more careful in a multithreaded environement
  if (!orwl_timestart) {
    mach_timebase_info_data_t tb = { 0 };
    mach_timebase_info(&tb);
    orwl_timebase = tb.numer;
    orwl_timebase /= tb.denom;
    orwl_timestart = mach_absolute_time();
  }
  struct timespec t;
  double diff = (mach_absolute_time() - orwl_timestart) * orwl_timebase;
  t.tv_sec = diff * ORWL_NANO;
  t.tv_nsec = diff - (t.tv_sec * ORWL_GIGA);
  return t;
}

Aucune des solutions ci-dessus répond à la question. Soit ils ne vous donnent pas absolue heure Unix, ou leur précision est de 1 microseconde. Le plus populaire de la solution par jbenet est lent (~6000ns) et ne compte pas en nanosecondes, même si son retour suggère donc. Ci-dessous est un test pour les 2 solutions proposées par jbenet et Dmitri B, de plus, mon prendre sur cette. Vous pouvez exécuter le code sans modification.

La 3ème solution ne compte pas en nanosecondes et vous donne absolue Unix de temps assez rapide (~90ns). Donc, si quelqu'un la trouver utile - s'il vous plaît laissez-nous le savons tous ici :-). Je m'en tiendrai à celle de Dmitri B (solution n ° 1 dans le code) - il correspond à mes besoins mieux.

J'avais besoin de qualité commerciale alternative à clock_gettime() pour faire pthread_...chronométré.. appels, et trouvé ce débat très utile. Merci les gars.

/*
Ratings of alternatives to clock_gettime() to use with pthread timed waits:
Solution 1 "gettimeofday":
Complexity      : simple
Portability     : POSIX 1
timespec        : easy to convert from timeval to timespec
granularity     : 1000 ns,
call            : 120 ns,
Rating          : the best.
Solution 2 "host_get_clock_service, clock_get_time":
Complexity      : simple (error handling?)
Portability     : Mac specific (is it always available?)
timespec        : yes (struct timespec return)
granularity     : 1000 ns (don't be fooled by timespec format)
call time       : 6000 ns
Rating          : the worst.
Solution 3 "mach_absolute_time + gettimeofday once":
Complexity      : simple..average (requires initialisation)
Portability     : Mac specific. Always available
timespec        : system clock can be converted to timespec without float-math
granularity     : 1 ns.
call time       : 90 ns unoptimised.
Rating          : not bad, but do we really need nanoseconds timeout?
References:
- OS X is UNIX System 3 [U03] certified
http://www.opengroup.org/homepage-items/c987.html
- UNIX System 3 <--> POSIX 1 <--> IEEE Std 1003.1-1988
http://en.wikipedia.org/wiki/POSIX
http://www.unix.org/version3/
- gettimeofday() is mandatory on U03,
clock_..() functions are optional on U03,
clock_..() are part of POSIX Realtime extensions
http://www.unix.org/version3/inttables.pdf
- clock_gettime() is not available on MacMini OS X
(Xcode > Preferences > Downloads > Command Line Tools = Installed)
- OS X recommends to use gettimeofday to calculate values for timespec
https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man3/pthread_cond_timedwait.3.html
- timeval holds microseconds, timespec - nanoseconds
http://www.gnu.org/software/libc/manual/html_node/Elapsed-Time.html
- microtime() is used by kernel to implement gettimeofday()
http://ftp.tw.freebsd.org/pub/branches/7.0-stable/src/sys/kern/kern_time.c
- mach_absolute_time() is really fast
http://www.opensource.apple.com/source/Libc/Libc-320.1.3/i386/mach/mach_absolute_time.c
- Only 9 deciaml digits have meaning when int nanoseconds converted to double seconds
Tutorial: Performance and Time post uses .12 precision for nanoseconds
http://www.macresearch.org/tutorial_performance_and_time
Example:
Three ways to prepare absolute time 1500 milliseconds in the future to use with pthread timed functions.
Output, N = 3, stock MacMini, OSX 10.7.5, 2.3GHz i5, 2GB 1333MHz DDR3:
inittime.tv_sec = 1390659993
inittime.tv_nsec = 361539000
initclock = 76672695144136
get_abs_future_time_0() : 1390659994.861599000
get_abs_future_time_0() : 1390659994.861599000
get_abs_future_time_0() : 1390659994.861599000
get_abs_future_time_1() : 1390659994.861618000
get_abs_future_time_1() : 1390659994.861634000
get_abs_future_time_1() : 1390659994.861642000
get_abs_future_time_2() : 1390659994.861643671
get_abs_future_time_2() : 1390659994.861643877
get_abs_future_time_2() : 1390659994.861643972
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>       /* gettimeofday */
#include <mach/mach_time.h> /* mach_absolute_time */
#include <mach/mach.h>      /* host_get_clock_service, mach_... */
#include <mach/clock.h>     /* clock_get_time */
#define BILLION 1000000000L
#define MILLION 1000000L
#define NORMALISE_TIMESPEC( ts, uint_milli )            \
do {                                                \
ts.tv_sec += uint_milli / 1000u;                \
ts.tv_nsec += (uint_milli % 1000u) * MILLION;   \
ts.tv_sec += ts.tv_nsec / BILLION;              \
ts.tv_nsec = ts.tv_nsec % BILLION;              \
} while (0)
static mach_timebase_info_data_t timebase = { 0, 0 }; /* numer = 0, denom = 0 */
static struct timespec           inittime = { 0, 0 }; /* nanoseconds since 1-Jan-1970 to init() */
static uint64_t                  initclock;           /* ticks since boot to init() */
void init()
{
struct timeval  micro;      /* microseconds since 1 Jan 1970 */
if (mach_timebase_info(&timebase) != 0)
abort();                            /* very unlikely error */
if (gettimeofday(&micro, NULL) != 0)
abort();                            /* very unlikely error */
initclock = mach_absolute_time();
inittime.tv_sec = micro.tv_sec;
inittime.tv_nsec = micro.tv_usec * 1000;
printf("\tinittime.tv_sec = %ld\n", inittime.tv_sec);
printf("\tinittime.tv_nsec = %ld\n", inittime.tv_nsec);
printf("\tinitclock = %ld\n", (long)initclock);
}
/*
* Get absolute future time for pthread timed calls
*  Solution 1: microseconds granularity
*/
struct timespec get_abs_future_time_coarse(unsigned milli)
{
struct timespec future;         /* ns since 1 Jan 1970 to 1500 ms in the future */
struct timeval  micro = {0, 0}; /* 1 Jan 1970 */
(void) gettimeofday(&micro, NULL);
future.tv_sec = micro.tv_sec;
future.tv_nsec = micro.tv_usec * 1000;
NORMALISE_TIMESPEC( future, milli );
return future;
}
/*
* Solution 2: via clock service
*/
struct timespec get_abs_future_time_served(unsigned milli)
{
struct timespec     future;
clock_serv_t        cclock;
mach_timespec_t     mts;
host_get_clock_service(mach_host_self(), CALENDAR_CLOCK, &cclock);
clock_get_time(cclock, &mts);
mach_port_deallocate(mach_task_self(), cclock);
future.tv_sec = mts.tv_sec;
future.tv_nsec = mts.tv_nsec;
NORMALISE_TIMESPEC( future, milli );
return future;
}
/*
* Solution 3: nanosecond granularity
*/
struct timespec get_abs_future_time_fine(unsigned milli)
{
struct timespec future;     /* ns since 1 Jan 1970 to 1500 ms in future */
uint64_t        clock;      /* ticks since init */
uint64_t        nano;       /* nanoseconds since init */
clock = mach_absolute_time() - initclock;
nano = clock * (uint64_t)timebase.numer / (uint64_t)timebase.denom;
future = inittime;
future.tv_sec += nano / BILLION;
future.tv_nsec += nano % BILLION;
NORMALISE_TIMESPEC( future, milli );
return future;
}
#define N 3
int main()
{
int                 i, j;
struct timespec     time[3][N];
struct timespec   (*get_abs_future_time[])(unsigned milli) =
{
&get_abs_future_time_coarse,
&get_abs_future_time_served,
&get_abs_future_time_fine
};
init();
for (j = 0; j < 3; j++)
for (i = 0; i < N; i++)
time[j][i] = get_abs_future_time[j](1500);  /* now() + 1500 ms */
for (j = 0; j < 3; j++)
for (i = 0; i < N; i++)
printf("get_abs_future_time_%d() : %10ld.%09ld\n",
j, time[j][i].tv_sec, time[j][i].tv_nsec);
return 0;
}

Tout ce dont vous avez besoin est décrit dans Technique Q&UN QA1398: Technique Q&UN QA1398: Mach Absolu Unités de Temps, fondamentalement, la fonction que vous voulez est mach_absolute_time.

Ici est un peu une version antérieure de l'échantillon de code de la page qui fait tout à l'aide de Mach appels (la version actuelle utilise AbsoluteToNanoseconds de CoreServices). Dans le courant de l'OS X (c'est à dire, sur Snow Leopard sur x86_64) l'absolu des valeurs de temps sont en fait en nanosecondes et donc ne nécessite pas réellement de conversion à tous. Donc, si vous êtes bon et écrire du code portable, vous pourrez convertir, mais si vous êtes en train de faire quelque chose de rapide et sale pour vous-même, vous n'avez pas besoin de s'embêter.

FWIW, mach_absolute_time est vraiment rapide.

uint64_t GetPIDTimeInNanoseconds(void)
{
uint64_t        start;
uint64_t        end;
uint64_t        elapsed;
uint64_t        elapsedNano;
static mach_timebase_info_data_t    sTimebaseInfo;
//Start the clock.
start = mach_absolute_time();
//Call getpid. This will produce inaccurate results because 
//we're only making a single system call. For more accurate 
//results you should call getpid multiple times and average 
//the results.
(void) getpid();
//Stop the clock.
end = mach_absolute_time();
//Calculate the duration.
elapsed = end - start;
//Convert to nanoseconds.
//If this is the first time we've run, get the timebase.
//We can use denom == 0 to indicate that sTimebaseInfo is 
//uninitialised because it makes no sense to have a zero 
//denominator is a fraction.
if ( sTimebaseInfo.denom == 0 ) {
(void) mach_timebase_info(&sTimebaseInfo);
}
//Do the maths. We hope that the multiplication doesn't 
//overflow; the price you pay for working in fixed point.
elapsedNano = elapsed * sTimebaseInfo.numer / sTimebaseInfo.denom;
printf("multiplier %u /%u\n", sTimebaseInfo.numer, sTimebaseInfo.denom);
return elapsedNano;
}

Merci pour vos messages

Je pense que vous pouvez ajouter les lignes suivantes

#ifdef __MACH__
#include <mach/mach_time.h>
#define CLOCK_REALTIME 0
#define CLOCK_MONOTONIC 0
int clock_gettime(int clk_id, struct timespec *t){
mach_timebase_info_data_t timebase;
mach_timebase_info(&timebase);
uint64_t time;
time = mach_absolute_time();
double nseconds = ((double)time * (double)timebase.numer)/((double)timebase.denom);
double seconds = ((double)time * (double)timebase.numer)/((double)timebase.denom * 1e9);
t->tv_sec = seconds;
t->tv_nsec = nseconds;
return 0;
}
#else
#include <time.h>
#endif

Laissez-moi savoir ce que vous obtenez pour la latence et de la granularité

J'ai essayé la version avec clock_get_time, et ne s'en cache les host_get_clock_service appel. C'est beaucoup plus lent que gettimeofday, il faut plusieurs microsecondes par l'invocation. Et, ce qui est pire, la valeur de retour a étapes de 1000, c'est à dire c'est toujours la microseconde granularité.

J'aimerais des conseils pour utiliser gettimeofday, et de multiplier tv_usec par 1000.

Comme au moins aussi loin que Mountain Lion, mach_absolute_time() retourne nanosecondes et pas de temps absolu (ce qui était le nombre de cycles de bus).

Le code suivant sur mon MacBook Pro (2 GHz Core i7) ont montré que le temps d'appeler mach_absolute_time() moyenne 39 ns plus de 10 pistes (35 min, max 45), qui est essentiellement le temps entre le retour de deux appels à mach_absolute_time(), environ 1 invocation:

#include <stdint.h>
#include <mach/mach_time.h>
#include <iostream>
using namespace std;
int main()
{
uint64_t now, then;
uint64_t abs;
then = mach_absolute_time(); //return nanoseconds
now = mach_absolute_time();
abs = now - then;
cout << "nanoseconds = " << abs << endl;
}

void clock_get_uptime(uint64_t *result);
void clock_get_system_microtime(            uint32_t *secs,
uint32_t *microsecs);
void clock_get_system_nanotime(             uint32_t *secs,
uint32_t *nanosecs);
void clock_get_calendar_microtime(          uint32_t *secs,
uint32_t *microsecs);
void clock_get_calendar_nanotime(           uint32_t *secs,
uint32_t *nanosecs);

Pour MacOS, vous pouvez trouver une bonne information sur leurs développeurs page
https://developer.apple.com/library/content/documentation/Darwin/Conceptual/KernelProgramming/services/services.html