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         int ret;
  46
  47         ret = fio_setaffinity(gettid(), fio_gtod_cpumask);
  48
  49         fio_mutex_up(mutex);
  50
  51         if (ret == -1) {
  52                 log_err("gtod: setaffinity failed\n");
  53                 return NULL;
  54         }
  55
  56         /*
  57          * As long as we have jobs around, update the clock. It would be nice
  58          * to have some way of NOT hammering that CPU with gettimeofday(),
  59          * but I'm not sure what to use outside of a simple CPU nop to relax
  60          * it - we don't want to lose precision.
  61          */
  62         while (threads) {
  63                 fio_gtod_update();
  64                 nop;
  65         }
  66
  67         return NULL;
  68 }
  69
  70 int fio_start_gtod_thread(void)
  71 {
  72         struct fio_mutex *mutex;
  73         pthread_attr_t attr;
  74         int ret;
  75
  76         mutex = fio_mutex_init(FIO_MUTEX_LOCKED);
  77         if (!mutex)
  78                 return 1;
  79
  80         pthread_attr_init(&attr);
  81         pthread_attr_setstacksize(&attr, 2 * PTHREAD_STACK_MIN);
  82         ret = pthread_create(&gtod_thread, &attr, gtod_thread_main, mutex);
  83         pthread_attr_destroy(&attr);
  84         if (ret) {
  85                 log_err("Can't create gtod thread: %s\n", strerror(ret));
  86                 goto err;
  87         }
  88
  89         ret = pthread_detach(gtod_thread);
  90         if (ret) {
  91                 log_err("Can't detach gtod thread: %s\n", strerror(ret));
  92                 goto err;
  93         }
  94
  95         dprint(FD_MUTEX, "wait on startup_mutex\n");
  96         fio_mutex_down(mutex);
  97         dprint(FD_MUTEX, "done waiting on startup_mutex\n");
  98 err:
  99         fio_mutex_remove(mutex);
 100         return ret;
 101 }
 102
 103 void fio_gtod_set_cpu(unsigned int cpu)
 104 {
 105 #ifdef FIO_HAVE_CPU_AFFINITY
 106         fio_cpu_set(&fio_gtod_cpumask, cpu);
 107 #endif
 108 }