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