helper_thread: split into separate file

It's nicely contained now, split it into its own set of files.

Signed-off-by: Jens Axboe <axboe@fb.com>

diff --git a/Makefile b/Makefile
index 1926f54e19f4aa53b4f38fe2247a63f6364294f0..00c119458d39f8595bedc57c242c891dd8b6812c 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -45,7 +45,7 @@ SOURCE :=     $(patsubst $(SRCDIR)/%,%,$(wildcard $(SRCDIR)/crc/*.c)) \
                server.c client.c iolog.c backend.c libfio.c flow.c cconv.c \
                gettime-thread.c helpers.c json.c idletime.c td_error.c \
                profiles/tiobench.c profiles/act.c io_u_queue.c filelock.c \
-               workqueue.c rate-submit.c optgroup.c
+               workqueue.c rate-submit.c optgroup.c helper_thread.c
 
 ifdef CONFIG_LIBHDFS
   HDFSFLAGS= -I $(JAVA_HOME)/include -I $(JAVA_HOME)/include/linux -I $(FIO_LIBHDFS_INCLUDE)

diff --git a/backend.c b/backend.c
index f0cb1bc34cf91937b119c54186276a0aea696a26..7de6f654d153b2f2798450ed4298a6d2c6763a2d 100644 (file)
--- a/backend.c
+++ b/backend.c
@@ -57,6 +57,7 @@
 #include "workqueue.h"
 #include "lib/mountcheck.h"
 #include "rate-submit.h"
+#include "helper_thread.h"
 
 static struct fio_mutex *startup_mutex;
 static struct flist_head *cgroup_list;
@@ -75,16 +76,6 @@ int shm_id = 0;
 int temp_stall_ts;
 unsigned long done_secs = 0;
 
-static struct helper_data {
-       volatile int exit;
-       volatile int reset;
-       volatile int do_stat;
-       struct sk_out *sk_out;
-       pthread_t thread;
-       pthread_mutex_t lock;
-       pthread_cond_t cond;
-} *helper_data;
-
 #define PAGE_ALIGN(buf)        \
        (char *) (((uintptr_t) (buf) + page_mask) & ~page_mask)
 
@@ -2323,158 +2314,10 @@ reap:
        update_io_ticks();
 }
 
-void helper_reset(void)
-{
-       if (!helper_data)
-               return;
-
-       pthread_mutex_lock(&helper_data->lock);
-
-       if (!helper_data->reset) {
-               helper_data->reset = 1;
-               pthread_cond_signal(&helper_data->cond);
-       }
-
-       pthread_mutex_unlock(&helper_data->lock);
-}
-
-void helper_do_stat(void)
-{
-       if (!helper_data)
-               return;
-
-       pthread_mutex_lock(&helper_data->lock);
-       helper_data->do_stat = 1;
-       pthread_cond_signal(&helper_data->cond);
-       pthread_mutex_unlock(&helper_data->lock);
-}
-
-bool helper_should_exit(void)
-{
-       if (!helper_data)
-               return true;
-
-       return helper_data->exit;
-}
-
-static void wait_for_helper_thread_exit(void)
-{
-       void *ret;
-
-       pthread_mutex_lock(&helper_data->lock);
-       helper_data->exit = 1;
-       pthread_cond_signal(&helper_data->cond);
-       pthread_mutex_unlock(&helper_data->lock);
-
-       pthread_join(helper_data->thread, &ret);
-}
-
 static void free_disk_util(void)
 {
        disk_util_prune_entries();
-
-       pthread_cond_destroy(&helper_data->cond);
-       pthread_mutex_destroy(&helper_data->lock);
-       sfree(helper_data);
-}
-
-static void *helper_thread_main(void *data)
-{
-       struct helper_data *hd = data;
-       unsigned int msec_to_next_event, next_log;
-       struct timeval tv, last_du;
-       int ret = 0;
-
-       sk_out_assign(hd->sk_out);
-
-       gettimeofday(&tv, NULL);
-       memcpy(&last_du, &tv, sizeof(tv));
-
-       fio_mutex_up(startup_mutex);
-
-       msec_to_next_event = DISK_UTIL_MSEC;
-       while (!ret && !hd->exit) {
-               struct timespec ts;
-               struct timeval now;
-               uint64_t since_du;
-
-               timeval_add_msec(&tv, msec_to_next_event);
-               ts.tv_sec = tv.tv_sec;
-               ts.tv_nsec = tv.tv_usec * 1000;
-
-               pthread_mutex_lock(&hd->lock);
-               pthread_cond_timedwait(&hd->cond, &hd->lock, &ts);
-
-               gettimeofday(&now, NULL);
-
-               if (hd->reset) {
-                       memcpy(&tv, &now, sizeof(tv));
-                       memcpy(&last_du, &now, sizeof(last_du));
-                       hd->reset = 0;
-               }
-
-               pthread_mutex_unlock(&hd->lock);
-
-               since_du = mtime_since(&last_du, &now);
-               if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) {
-                       ret = update_io_ticks();
-                       timeval_add_msec(&last_du, DISK_UTIL_MSEC);
-                       msec_to_next_event = DISK_UTIL_MSEC;
-                       if (since_du >= DISK_UTIL_MSEC)
-                               msec_to_next_event -= (since_du - DISK_UTIL_MSEC);
-               } else {
-                       if (since_du >= DISK_UTIL_MSEC)
-                               msec_to_next_event = DISK_UTIL_MSEC - (DISK_UTIL_MSEC - since_du);
-                       else
-                               msec_to_next_event = DISK_UTIL_MSEC;
-               }
-
-               if (hd->do_stat) {
-                       hd->do_stat = 0;
-                       __show_running_run_stats();
-               }
-
-               next_log = calc_log_samples();
-               if (!next_log)
-                       next_log = DISK_UTIL_MSEC;
-
-               msec_to_next_event = min(next_log, msec_to_next_event);
-
-               if (!is_backend)
-                       print_thread_status();
-       }
-
-       fio_writeout_logs(false);
-
-       sk_out_drop();
-       return NULL;
-}
-
-static int create_helper_thread(struct sk_out *sk_out)
-{
-       struct helper_data *hd;
-       int ret;
-
-       hd = smalloc(sizeof(*hd));
-
-       setup_disk_util();
-
-       hd->sk_out = sk_out;
-       pthread_cond_init(&hd->cond, NULL);
-       pthread_mutex_init(&hd->lock, NULL);
-
-       ret = pthread_create(&hd->thread, NULL, helper_thread_main, hd);
-       if (ret) {
-               log_err("Can't create helper thread: %s\n", strerror(ret));
-               return 1;
-       }
-
-       helper_data = hd;
-
-       dprint(FD_MUTEX, "wait on startup_mutex\n");
-       fio_mutex_down(startup_mutex);
-       dprint(FD_MUTEX, "done waiting on startup_mutex\n");
-       return 0;
+       helper_thread_destroy();
 }
 
 int fio_backend(struct sk_out *sk_out)
@@ -2507,14 +2350,14 @@ int fio_backend(struct sk_out *sk_out)
 
        set_genesis_time();
        stat_init();
-       create_helper_thread(sk_out);
+       helper_thread_create(startup_mutex, sk_out);
 
        cgroup_list = smalloc(sizeof(*cgroup_list));
        INIT_FLIST_HEAD(cgroup_list);
 
        run_threads(sk_out);
 
-       wait_for_helper_thread_exit();
+       helper_thread_exit();
 
        if (!fio_abort) {
                __show_run_stats();

diff --git a/diskutil.c b/diskutil.c
index 315c1e10a2d8e18482585696ae30594d1999c217..8031d5d9ce7e6130977c1034a5c82c8106882ea6 100644 (file)
--- a/diskutil.c
+++ b/diskutil.c
@@ -11,6 +11,7 @@
 #include "fio.h"
 #include "smalloc.h"
 #include "diskutil.h"
+#include "helper_thread.h"
 
 static int last_majdev, last_mindev;
 static struct disk_util *last_du;

diff --git a/fio.h b/fio.h
index 20ff26fcac6dd3c8e606e6356bce915b2ad3d17f..6a244c38896e820c6c23da16a5a661c6fefb1f94 100644 (file)
--- a/fio.h
+++ b/fio.h
@@ -732,8 +732,4 @@ enum {
 extern void exec_trigger(const char *);
 extern void check_trigger_file(void);
 
-extern void helper_reset(void);
-extern void helper_do_stat(void);
-extern bool helper_should_exit(void);
-
 #endif

diff --git a/helper_thread.c b/helper_thread.c
new file mode 100644 (file)
index 0000000..1befabf
--- /dev/null
+++ b/helper_thread.c
@@ -0,0 +1,167 @@
+#include "fio.h"
+#include "smalloc.h"
+#include "helper_thread.h"
+
+static struct helper_data {
+       volatile int exit;
+       volatile int reset;
+       volatile int do_stat;
+       struct sk_out *sk_out;
+       pthread_t thread;
+       pthread_mutex_t lock;
+       pthread_cond_t cond;
+       struct fio_mutex *startup_mutex;
+} *helper_data;
+
+void helper_thread_destroy(void)
+{
+       pthread_cond_destroy(&helper_data->cond);
+       pthread_mutex_destroy(&helper_data->lock);
+       sfree(helper_data);
+}
+
+void helper_reset(void)
+{
+       if (!helper_data)
+               return;
+
+       pthread_mutex_lock(&helper_data->lock);
+
+       if (!helper_data->reset) {
+               helper_data->reset = 1;
+               pthread_cond_signal(&helper_data->cond);
+       }
+
+       pthread_mutex_unlock(&helper_data->lock);
+}
+
+void helper_do_stat(void)
+{
+       if (!helper_data)
+               return;
+
+       pthread_mutex_lock(&helper_data->lock);
+       helper_data->do_stat = 1;
+       pthread_cond_signal(&helper_data->cond);
+       pthread_mutex_unlock(&helper_data->lock);
+}
+
+bool helper_should_exit(void)
+{
+       if (!helper_data)
+               return true;
+
+       return helper_data->exit;
+}
+
+void helper_thread_exit(void)
+{
+       void *ret;
+
+       pthread_mutex_lock(&helper_data->lock);
+       helper_data->exit = 1;
+       pthread_cond_signal(&helper_data->cond);
+       pthread_mutex_unlock(&helper_data->lock);
+
+       pthread_join(helper_data->thread, &ret);
+}
+
+static void *helper_thread_main(void *data)
+{
+       struct helper_data *hd = data;
+       unsigned int msec_to_next_event, next_log;
+       struct timeval tv, last_du;
+       int ret = 0;
+
+       sk_out_assign(hd->sk_out);
+
+       gettimeofday(&tv, NULL);
+       memcpy(&last_du, &tv, sizeof(tv));
+
+       fio_mutex_up(hd->startup_mutex);
+
+       msec_to_next_event = DISK_UTIL_MSEC;
+       while (!ret && !hd->exit) {
+               struct timespec ts;
+               struct timeval now;
+               uint64_t since_du;
+
+               timeval_add_msec(&tv, msec_to_next_event);
+               ts.tv_sec = tv.tv_sec;
+               ts.tv_nsec = tv.tv_usec * 1000;
+
+               pthread_mutex_lock(&hd->lock);
+               pthread_cond_timedwait(&hd->cond, &hd->lock, &ts);
+
+               gettimeofday(&now, NULL);
+
+               if (hd->reset) {
+                       memcpy(&tv, &now, sizeof(tv));
+                       memcpy(&last_du, &now, sizeof(last_du));
+                       hd->reset = 0;
+               }
+
+               pthread_mutex_unlock(&hd->lock);
+
+               since_du = mtime_since(&last_du, &now);
+               if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) {
+                       ret = update_io_ticks();
+                       timeval_add_msec(&last_du, DISK_UTIL_MSEC);
+                       msec_to_next_event = DISK_UTIL_MSEC;
+                       if (since_du >= DISK_UTIL_MSEC)
+                               msec_to_next_event -= (since_du - DISK_UTIL_MSEC);
+               } else {
+                       if (since_du >= DISK_UTIL_MSEC)
+                               msec_to_next_event = DISK_UTIL_MSEC - (DISK_UTIL_MSEC - since_du);
+                       else
+                               msec_to_next_event = DISK_UTIL_MSEC;
+               }
+
+               if (hd->do_stat) {
+                       hd->do_stat = 0;
+                       __show_running_run_stats();
+               }
+
+               next_log = calc_log_samples();
+               if (!next_log)
+                       next_log = DISK_UTIL_MSEC;
+
+               msec_to_next_event = min(next_log, msec_to_next_event);
+
+               if (!is_backend)
+                       print_thread_status();
+       }
+
+       fio_writeout_logs(false);
+
+       sk_out_drop();
+       return NULL;
+}
+
+int helper_thread_create(struct fio_mutex *startup_mutex, struct sk_out *sk_out)
+{
+       struct helper_data *hd;
+       int ret;
+
+       hd = smalloc(sizeof(*hd));
+
+       setup_disk_util();
+
+       hd->sk_out = sk_out;
+       pthread_cond_init(&hd->cond, NULL);
+       pthread_mutex_init(&hd->lock, NULL);
+       hd->startup_mutex = startup_mutex;
+
+       ret = pthread_create(&hd->thread, NULL, helper_thread_main, hd);
+       if (ret) {
+               log_err("Can't create helper thread: %s\n", strerror(ret));
+               return 1;
+       }
+
+       helper_data = hd;
+
+       dprint(FD_MUTEX, "wait on startup_mutex\n");
+       fio_mutex_down(startup_mutex);
+       dprint(FD_MUTEX, "done waiting on startup_mutex\n");
+       return 0;
+}

diff --git a/helper_thread.h b/helper_thread.h
new file mode 100644 (file)
index 0000000..78933b1
--- /dev/null
+++ b/helper_thread.h
@@ -0,0 +1,11 @@
+#ifndef FIO_HELPER_THREAD_H
+#define FIO_HELPER_THREAD_H
+
+extern void helper_reset(void);
+extern void helper_do_stat(void);
+extern bool helper_should_exit(void);
+extern void helper_thread_destroy(void);
+extern void helper_thread_exit(void);
+extern int helper_thread_create(struct fio_mutex *, struct sk_out *);
+
+#endif

diff --git a/libfio.c b/libfio.c
index 790c0364b493f77606171ac6b6e399d110c140bf..55762d7be3cc99617c95e9981f9cc40413e3b4c0 100644 (file)
--- a/libfio.c
+++ b/libfio.c
@@ -33,6 +33,7 @@
 #include "smalloc.h"
 #include "os/os.h"
 #include "filelock.h"
+#include "helper_thread.h"
 
 /*
  * Just expose an empty list, if the OS does not support disk util stats

diff --git a/stat.c b/stat.c
index 7db41376913170fec8faeefd7bc457f2bad8228a..95f206e049960c986ff78e683f4da05193d51f3c 100644 (file)
--- a/stat.c
+++ b/stat.c
@@ -15,6 +15,7 @@
 #include "idletime.h"
 #include "lib/pow2.h"
 #include "lib/output_buffer.h"
+#include "helper_thread.h"
 
 struct fio_mutex *stat_mutex;