helper_thread.c

   1 #ifdef CONFIG_VALGRIND_DEV
   2 #include <valgrind/drd.h>
   3 #else
   4 #define DRD_IGNORE_VAR(x) do { } while (0)
   5 #endif
   6
   7 #include "fio.h"
   8 #include "smalloc.h"
   9 #include "helper_thread.h"
  10 #include "steadystate.h"
  11 #include "pshared.h"
  12
  13 static struct helper_data {
  14         volatile int exit;
  15         volatile int reset;
  16         volatile int do_stat;
  17         struct sk_out *sk_out;
  18         pthread_t thread;
  19         pthread_mutex_t lock;
  20         pthread_cond_t cond;
  21         struct fio_sem *startup_sem;
  22 } *helper_data;
  23
  24 void helper_thread_destroy(void)
  25 {
  26         pthread_cond_destroy(&helper_data->cond);
  27         pthread_mutex_destroy(&helper_data->lock);
  28         sfree(helper_data);
  29 }
  30
  31 void helper_reset(void)
  32 {
  33         if (!helper_data)
  34                 return;
  35
  36         pthread_mutex_lock(&helper_data->lock);
  37
  38         if (!helper_data->reset) {
  39                 helper_data->reset = 1;
  40                 pthread_cond_signal(&helper_data->cond);
  41         }
  42
  43         pthread_mutex_unlock(&helper_data->lock);
  44 }
  45
  46 void helper_do_stat(void)
  47 {
  48         if (!helper_data)
  49                 return;
  50
  51         pthread_mutex_lock(&helper_data->lock);
  52         helper_data->do_stat = 1;
  53         pthread_cond_signal(&helper_data->cond);
  54         pthread_mutex_unlock(&helper_data->lock);
  55 }
  56
  57 bool helper_should_exit(void)
  58 {
  59         if (!helper_data)
  60                 return true;
  61
  62         return helper_data->exit;
  63 }
  64
  65 void helper_thread_exit(void)
  66 {
  67         void *ret;
  68
  69         pthread_mutex_lock(&helper_data->lock);
  70         helper_data->exit = 1;
  71         pthread_cond_signal(&helper_data->cond);
  72         pthread_mutex_unlock(&helper_data->lock);
  73
  74         pthread_join(helper_data->thread, &ret);
  75 }
  76
  77 static void *helper_thread_main(void *data)
  78 {
  79         struct helper_data *hd = data;
  80         unsigned int msec_to_next_event, next_log, next_ss = STEADYSTATE_MSEC;
  81         struct timespec ts, last_du, last_ss;
  82         int ret = 0;
  83
  84         sk_out_assign(hd->sk_out);
  85
  86 #ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
  87         clock_gettime(CLOCK_MONOTONIC, &ts);
  88 #else
  89         clock_gettime(CLOCK_REALTIME, &ts);
  90 #endif
  91         memcpy(&last_du, &ts, sizeof(ts));
  92         memcpy(&last_ss, &ts, sizeof(ts));
  93
  94         fio_sem_up(hd->startup_sem);
  95
  96         msec_to_next_event = DISK_UTIL_MSEC;
  97         while (!ret && !hd->exit) {
  98                 uint64_t since_du, since_ss = 0;
  99
 100                 timespec_add_msec(&ts, msec_to_next_event);
 101
 102                 pthread_mutex_lock(&hd->lock);
 103                 pthread_cond_timedwait(&hd->cond, &hd->lock, &ts);
 104
 105 #ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK
 106                 clock_gettime(CLOCK_MONOTONIC, &ts);
 107 #else
 108                 clock_gettime(CLOCK_REALTIME, &ts);
 109 #endif
 110
 111                 if (hd->reset) {
 112                         memcpy(&last_du, &ts, sizeof(ts));
 113                         memcpy(&last_ss, &ts, sizeof(ts));
 114                         hd->reset = 0;
 115                 }
 116
 117                 pthread_mutex_unlock(&hd->lock);
 118
 119                 since_du = mtime_since(&last_du, &ts);
 120                 if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) {
 121                         ret = update_io_ticks();
 122                         timespec_add_msec(&last_du, DISK_UTIL_MSEC);
 123                         msec_to_next_event = DISK_UTIL_MSEC;
 124                         if (since_du >= DISK_UTIL_MSEC)
 125                                 msec_to_next_event -= (since_du - DISK_UTIL_MSEC);
 126                 } else
 127                         msec_to_next_event = DISK_UTIL_MSEC - since_du;
 128
 129                 if (hd->do_stat) {
 130                         hd->do_stat = 0;
 131                         __show_running_run_stats();
 132                 }
 133
 134                 next_log = calc_log_samples();
 135                 if (!next_log)
 136                         next_log = DISK_UTIL_MSEC;
 137
 138                 if (steadystate_enabled) {
 139                         since_ss = mtime_since(&last_ss, &ts);
 140                         if (since_ss >= STEADYSTATE_MSEC || STEADYSTATE_MSEC - since_ss < 10) {
 141                                 steadystate_check();
 142                                 timespec_add_msec(&last_ss, since_ss);
 143                                 if (since_ss > STEADYSTATE_MSEC)
 144                                         next_ss = STEADYSTATE_MSEC - (since_ss - STEADYSTATE_MSEC);
 145                                 else
 146                                         next_ss = STEADYSTATE_MSEC;
 147                         } else
 148                                 next_ss = STEADYSTATE_MSEC - since_ss;
 149                 }
 150
 151                 msec_to_next_event = min(min(next_log, msec_to_next_event), next_ss);
 152                 dprint(FD_HELPERTHREAD, "since_ss: %llu, next_ss: %u, next_log: %u, msec_to_next_event: %u\n", (unsigned long long)since_ss, next_ss, next_log, msec_to_next_event);
 153
 154                 if (!is_backend)
 155                         print_thread_status();
 156         }
 157
 158         fio_writeout_logs(false);
 159
 160         sk_out_drop();
 161         return NULL;
 162 }
 163
 164 int helper_thread_create(struct fio_sem *startup_sem, struct sk_out *sk_out)
 165 {
 166         struct helper_data *hd;
 167         int ret;
 168
 169         hd = scalloc(1, sizeof(*hd));
 170
 171         setup_disk_util();
 172         steadystate_setup();
 173
 174         hd->sk_out = sk_out;
 175
 176         ret = mutex_cond_init_pshared(&hd->lock, &hd->cond);
 177         if (ret)
 178                 return 1;
 179
 180         hd->startup_sem = startup_sem;
 181
 182         DRD_IGNORE_VAR(helper_data);
 183
 184         ret = pthread_create(&hd->thread, NULL, helper_thread_main, hd);
 185         if (ret) {
 186                 log_err("Can't create helper thread: %s\n", strerror(ret));
 187                 return 1;
 188         }
 189
 190         helper_data = hd;
 191
 192         dprint(FD_MUTEX, "wait on startup_sem\n");
 193         fio_sem_down(startup_sem);
 194         dprint(FD_MUTEX, "done waiting on startup_sem\n");
 195         return 0;
 196 }