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 timeval tv;
  82         struct timespec ts, last_du, last_ss;
  83         int ret = 0;
  84
  85         sk_out_assign(hd->sk_out);
  86
  87         gettimeofday(&tv, NULL);
  88         ts.tv_sec = tv.tv_sec;
  89         ts.tv_nsec = tv.tv_usec * 1000;
  90         memcpy(&last_du, &ts, sizeof(ts));
  91         memcpy(&last_ss, &ts, sizeof(ts));
  92
  93         fio_sem_up(hd->startup_sem);
  94
  95         msec_to_next_event = DISK_UTIL_MSEC;
  96         while (!ret && !hd->exit) {
  97                 uint64_t since_du, since_ss = 0;
  98
  99                 timespec_add_msec(&ts, msec_to_next_event);
 100
 101                 pthread_mutex_lock(&hd->lock);
 102                 pthread_cond_timedwait(&hd->cond, &hd->lock, &ts);
 103
 104                 gettimeofday(&tv, NULL);
 105                 ts.tv_sec = tv.tv_sec;
 106                 ts.tv_nsec = tv.tv_usec * 1000;
 107
 108                 if (hd->reset) {
 109                         memcpy(&last_du, &ts, sizeof(ts));
 110                         memcpy(&last_ss, &ts, sizeof(ts));
 111                         hd->reset = 0;
 112                 }
 113
 114                 pthread_mutex_unlock(&hd->lock);
 115
 116                 since_du = mtime_since(&last_du, &ts);
 117                 if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) {
 118                         ret = update_io_ticks();
 119                         timespec_add_msec(&last_du, DISK_UTIL_MSEC);
 120                         msec_to_next_event = DISK_UTIL_MSEC;
 121                         if (since_du >= DISK_UTIL_MSEC)
 122                                 msec_to_next_event -= (since_du - DISK_UTIL_MSEC);
 123                 } else
 124                         msec_to_next_event = DISK_UTIL_MSEC - since_du;
 125
 126                 if (hd->do_stat) {
 127                         hd->do_stat = 0;
 128                         __show_running_run_stats();
 129                 }
 130
 131                 next_log = calc_log_samples();
 132                 if (!next_log)
 133                         next_log = DISK_UTIL_MSEC;
 134
 135                 if (steadystate_enabled) {
 136                         since_ss = mtime_since(&last_ss, &ts);
 137                         if (since_ss >= STEADYSTATE_MSEC || STEADYSTATE_MSEC - since_ss < 10) {
 138                                 steadystate_check();
 139                                 timespec_add_msec(&last_ss, since_ss);
 140                                 if (since_ss > STEADYSTATE_MSEC)
 141                                         next_ss = STEADYSTATE_MSEC - (since_ss - STEADYSTATE_MSEC);
 142                                 else
 143                                         next_ss = STEADYSTATE_MSEC;
 144                         } else
 145                                 next_ss = STEADYSTATE_MSEC - since_ss;
 146                 }
 147
 148                 msec_to_next_event = min(min(next_log, msec_to_next_event), next_ss);
 149                 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);
 150
 151                 if (!is_backend)
 152                         print_thread_status();
 153         }
 154
 155         fio_writeout_logs(false);
 156
 157         sk_out_drop();
 158         return NULL;
 159 }
 160
 161 int helper_thread_create(struct fio_sem *startup_sem, struct sk_out *sk_out)
 162 {
 163         struct helper_data *hd;
 164         int ret;
 165
 166         hd = scalloc(1, sizeof(*hd));
 167
 168         setup_disk_util();
 169         steadystate_setup();
 170
 171         hd->sk_out = sk_out;
 172
 173         ret = mutex_cond_init_pshared(&hd->lock, &hd->cond);
 174         if (ret)
 175                 return 1;
 176
 177         hd->startup_sem = startup_sem;
 178
 179         DRD_IGNORE_VAR(helper_data);
 180
 181         ret = pthread_create(&hd->thread, NULL, helper_thread_main, hd);
 182         if (ret) {
 183                 log_err("Can't create helper thread: %s\n", strerror(ret));
 184                 return 1;
 185         }
 186
 187         helper_data = hd;
 188
 189         dprint(FD_MUTEX, "wait on startup_sem\n");
 190         fio_sem_down(startup_sem);
 191         dprint(FD_MUTEX, "done waiting on startup_sem\n");
 192         return 0;
 193 }