gettime-thread.c

   1 #include <unistd.h>
   2 #include <math.h>
   3 #include <sys/time.h>
   4 #include <time.h>
   5
   6 #include "fio.h"
   7 #include "smalloc.h"
   8
   9 struct timespec *fio_ts = NULL;
  10 int fio_gtod_offload = 0;
  11 static pthread_t gtod_thread;
  12 static os_cpu_mask_t fio_gtod_cpumask;
  13
  14 void fio_gtod_init(void)
  15 {
  16         if (fio_ts)
  17                 return;
  18
  19         fio_ts = smalloc(sizeof(*fio_ts));
  20         if (!fio_ts)
  21                 log_err("fio: smalloc pool exhausted\n");
  22 }
  23
  24 static void fio_gtod_update(void)
  25 {
  26         if (fio_ts) {
  27                 struct timeval __tv;
  28
  29                 gettimeofday(&__tv, NULL);
  30                 fio_ts->tv_sec = __tv.tv_sec;
  31                 write_barrier();
  32                 fio_ts->tv_nsec = __tv.tv_usec * 1000;
  33                 write_barrier();
  34         }
  35 }
  36
  37 struct gtod_cpu_data {
  38         struct fio_mutex *mutex;
  39         unsigned int cpu;
  40 };
  41
  42 static void *gtod_thread_main(void *data)
  43 {
  44         struct fio_mutex *mutex = data;
  45
  46         fio_setaffinity(gettid(), fio_gtod_cpumask);
  47         fio_mutex_up(mutex);
  48
  49         /*
  50          * As long as we have jobs around, update the clock. It would be nice
  51          * to have some way of NOT hammering that CPU with gettimeofday(),
  52          * but I'm not sure what to use outside of a simple CPU nop to relax
  53          * it - we don't want to lose precision.
  54          */
  55         while (threads) {
  56                 fio_gtod_update();
  57                 nop;
  58         }
  59
  60         return NULL;
  61 }
  62
  63 int fio_start_gtod_thread(void)
  64 {
  65         struct fio_mutex *mutex;
  66         pthread_attr_t attr;
  67         int ret;
  68
  69         mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
  70         if (!mutex)
  71                 return 1;
  72
  73         pthread_attr_init(&attr);
  74         pthread_attr_setstacksize(&attr, 2 * PTHREAD_STACK_MIN);
  75         ret = pthread_create(&gtod_thread, &attr, gtod_thread_main, mutex);
  76         pthread_attr_destroy(&attr);
  77         if (ret) {
  78                 log_err("Can't create gtod thread: %s\n", strerror(ret));
  79                 goto err;
  80         }
  81
  82         ret = pthread_detach(gtod_thread);
  83         if (ret) {
  84                 log_err("Can't detach gtod thread: %s\n", strerror(ret));
  85                 goto err;
  86         }
  87
  88         dprint(FD_MUTEX, "wait on startup_mutex\n");
  89         fio_mutex_down(mutex);
  90         dprint(FD_MUTEX, "done waiting on startup_mutex\n");
  91 err:
  92         fio_mutex_remove(mutex);
  93         return ret;
  94 }
  95
  96 void fio_gtod_set_cpu(unsigned int cpu)
  97 {
  98 #ifdef FIO_HAVE_CPU_AFFINITY
  99         fio_cpu_set(&fio_gtod_cpumask, cpu);
 100 #endif
 101 }