From: Jens Axboe <axboe@kernel.dk>
Date: Thu, 9 Feb 2012 09:27:10 +0000 (+0100)
Subject: Move gtod thread to gettime.c
X-Git-Tag: fio-2.0.4~46
X-Git-Url: https://git.kernel.dk/?p=fio.git;a=commitdiff_plain;h=783a3eb15f143d26eed5fd1c943f238057f3ee52

Move gtod thread to gettime.c

Signed-off-by: Jens Axboe <axboe@kernel.dk>
---

diff --git a/fio.c b/fio.c
index 7aa55a8f..4f07214e 100644
--- a/fio.c
+++ b/fio.c
@@ -73,7 +73,6 @@ static struct fio_mutex *startup_mutex;
 static struct fio_mutex *writeout_mutex;
 static volatile int fio_abort;
 static int exit_value;
-static pthread_t gtod_thread;
 static pthread_t disk_util_thread;
 static struct flist_head *cgroup_list;
 static char *cgroup_mnt;
@@ -1502,50 +1501,6 @@ reaped:
 		fio_terminate_threads(TERMINATE_ALL);
 }
 
-static void *gtod_thread_main(void *data)
-{
-	fio_mutex_up(startup_mutex);
-
-	/*
-	 * As long as we have jobs around, update the clock. It would be nice
-	 * to have some way of NOT hammering that CPU with gettimeofday(),
-	 * but I'm not sure what to use outside of a simple CPU nop to relax
-	 * it - we don't want to lose precision.
-	 */
-	while (threads) {
-		fio_gtod_update();
-		nop;
-	}
-
-	return NULL;
-}
-
-static int fio_start_gtod_thread(void)
-{
-	pthread_attr_t attr;
-	int ret;
-
-	pthread_attr_init(&attr);
-	pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
-	ret = pthread_create(&gtod_thread, &attr, gtod_thread_main, NULL);
-	pthread_attr_destroy(&attr);
-	if (ret) {
-		log_err("Can't create gtod thread: %s\n", strerror(ret));
-		return 1;
-	}
-
-	ret = pthread_detach(gtod_thread);
-	if (ret) {
-		log_err("Can't detatch gtod thread: %s\n", strerror(ret));
-		return 1;
-	}
-
-	dprint(FD_MUTEX, "wait on startup_mutex\n");
-	fio_mutex_down(startup_mutex);
-	dprint(FD_MUTEX, "done waiting on startup_mutex\n");
-	return 0;
-}
-
 /*
  * Main function for kicking off and reaping jobs, as needed.
  */
diff --git a/gettime.c b/gettime.c
index 15356b1b..2037354d 100644
--- a/gettime.c
+++ b/gettime.c
@@ -22,6 +22,7 @@ static int last_tv_valid;
 static struct timeval *fio_tv;
 int fio_gtod_offload = 0;
 int fio_gtod_cpu = -1;
+static pthread_t gtod_thread;
 
 enum fio_cs fio_clock_source = CS_GTOD;
 
@@ -276,3 +277,56 @@ void fio_gtod_update(void)
 {
 	gettimeofday(fio_tv, NULL);
 }
+
+static void *gtod_thread_main(void *data)
+{
+	struct fio_mutex *mutex = data;
+
+	fio_mutex_up(mutex);
+
+	/*
+	 * As long as we have jobs around, update the clock. It would be nice
+	 * to have some way of NOT hammering that CPU with gettimeofday(),
+	 * but I'm not sure what to use outside of a simple CPU nop to relax
+	 * it - we don't want to lose precision.
+	 */
+	while (threads) {
+		fio_gtod_update();
+		nop;
+	}
+
+	return NULL;
+}
+
+int fio_start_gtod_thread(void)
+{
+	struct fio_mutex *mutex;
+	pthread_attr_t attr;
+	int ret;
+
+	mutex = fio_mutex_init(0);
+	if (!mutex)
+		return 1;
+
+	pthread_attr_init(&attr);
+	pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN);
+	ret = pthread_create(&gtod_thread, &attr, gtod_thread_main, NULL);
+	pthread_attr_destroy(&attr);
+	if (ret) {
+		log_err("Can't create gtod thread: %s\n", strerror(ret));
+		goto err;
+	}
+
+	ret = pthread_detach(gtod_thread);
+	if (ret) {
+		log_err("Can't detatch gtod thread: %s\n", strerror(ret));
+		goto err;
+	}
+
+	dprint(FD_MUTEX, "wait on startup_mutex\n");
+	fio_mutex_down(mutex);
+	dprint(FD_MUTEX, "done waiting on startup_mutex\n");
+err:
+	fio_mutex_remove(mutex);
+	return ret;
+}
diff --git a/time.h b/time.h
index 61ad5d80..bc7fe370 100644
--- a/time.h
+++ b/time.h
@@ -28,5 +28,6 @@ extern int ramp_time_over(struct thread_data *);
 extern int in_ramp_time(struct thread_data *);
 extern unsigned long long genesis_cycles;
 extern void fio_time_init(void);
+extern int fio_start_gtod_thread(void);
 
 #endif