From 39ab7da23768081db50b0026e0c2a8e38752e7a4 Mon Sep 17 00:00:00 2001 From: Jens Axboe Date: Tue, 6 Nov 2012 22:10:43 +0100 Subject: [PATCH] Move code around to satisfy t/stest linkage Signed-off-by: Jens Axboe --- Makefile | 4 +- gettime-thread.c | 78 ++++++++++++++++++++++++++++++++++++ gettime.c | 101 +++++++++++++++++++++++------------------------ gettime.h | 2 + t/stest.c | 6 +++ time.c | 66 ------------------------------- 6 files changed, 137 insertions(+), 120 deletions(-) create mode 100644 gettime-thread.c diff --git a/Makefile b/Makefile index 85da5132..88d397b6 100644 --- a/Makefile +++ b/Makefile @@ -15,7 +15,7 @@ SOURCE := gettime.c fio.c ioengines.c init.c stat.c log.c time.c filesetup.c \ lib/num2str.c lib/ieee754.c $(wildcard crc/*.c) engines/cpu.c \ engines/mmap.c engines/sync.c engines/null.c engines/net.c \ memalign.c server.c client.c iolog.c backend.c libfio.c flow.c \ - json.c lib/zipf.c + json.c lib/zipf.c gettime-thread.c ifeq ($(UNAME), Linux) SOURCE += diskutil.c fifo.c blktrace.c helpers.c cgroup.c trim.c \ @@ -69,7 +69,7 @@ endif OBJS = $(SOURCE:.c=.o) T_SMALLOC_OBJS = t/stest.o -T_SMALLOC_OBJS += mutex.o smalloc.o t/log.o +T_SMALLOC_OBJS += gettime.o mutex.o smalloc.o t/log.o T_SMALLOC_PROGS = t/stest T_IEEE_OBJS = t/ieee754.o diff --git a/gettime-thread.c b/gettime-thread.c new file mode 100644 index 00000000..da409042 --- /dev/null +++ b/gettime-thread.c @@ -0,0 +1,78 @@ +#include +#include +#include +#include + +#include "fio.h" +#include "smalloc.h" + +struct timeval *fio_tv; +int fio_gtod_offload = 0; +int fio_gtod_cpu = -1; +static pthread_t gtod_thread; + +void fio_gtod_init(void) +{ + fio_tv = smalloc(sizeof(struct timeval)); + assert(fio_tv); +} + +static 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(FIO_MUTEX_LOCKED); + if (!mutex) + return 1; + + pthread_attr_init(&attr); + pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN); + ret = pthread_create(>od_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/gettime.c b/gettime.c index 5b492875..35d685e1 100644 --- a/gettime.c +++ b/gettime.c @@ -19,11 +19,6 @@ static unsigned long last_cycles; static struct timeval last_tv; 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 = FIO_PREFERRED_CLOCK_SOURCE; #ifdef FIO_DEBUG_TIME @@ -267,66 +262,68 @@ void fio_clock_init(void) calibrate_cpu_clock(); } -void fio_gtod_init(void) +unsigned long long utime_since(struct timeval *s, struct timeval *e) { - fio_tv = smalloc(sizeof(struct timeval)); - assert(fio_tv); + long sec, usec; + unsigned long long ret; + + sec = e->tv_sec - s->tv_sec; + usec = e->tv_usec - s->tv_usec; + if (sec > 0 && usec < 0) { + sec--; + usec += 1000000; + } + + /* + * time warp bug on some kernels? + */ + if (sec < 0 || (sec == 0 && usec < 0)) + return 0; + + ret = sec * 1000000ULL + usec; + + return ret; } -static void fio_gtod_update(void) +unsigned long long utime_since_now(struct timeval *s) { - gettimeofday(fio_tv, NULL); + struct timeval t; + + fio_gettime(&t, NULL); + return utime_since(s, &t); } -static void *gtod_thread_main(void *data) +unsigned long mtime_since(struct timeval *s, struct timeval *e) { - struct fio_mutex *mutex = data; + long sec, usec, ret; - 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; + sec = e->tv_sec - s->tv_sec; + usec = e->tv_usec - s->tv_usec; + if (sec > 0 && usec < 0) { + sec--; + usec += 1000000; } - return NULL; + if (sec < 0 || (sec == 0 && usec < 0)) + return 0; + + sec *= 1000UL; + usec /= 1000UL; + ret = sec + usec; + + return ret; } -int fio_start_gtod_thread(void) +unsigned long mtime_since_now(struct timeval *s) { - struct fio_mutex *mutex; - pthread_attr_t attr; - int ret; - - mutex = fio_mutex_init(FIO_MUTEX_LOCKED); - if (!mutex) - return 1; - - pthread_attr_init(&attr); - pthread_attr_setstacksize(&attr, PTHREAD_STACK_MIN); - ret = pthread_create(>od_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; - } + struct timeval t; + void *p = __builtin_return_address(0); - ret = pthread_detach(gtod_thread); - if (ret) { - log_err("Can't detatch gtod thread: %s\n", strerror(ret)); - goto err; - } + fio_gettime(&t, p); + return mtime_since(s, &t); +} - 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; +unsigned long time_since_now(struct timeval *s) +{ + return mtime_since_now(s) / 1000; } diff --git a/gettime.h b/gettime.h index 87cc8954..309ef210 100644 --- a/gettime.h +++ b/gettime.h @@ -15,4 +15,6 @@ extern void fio_gtod_init(void); extern void fio_clock_init(void); extern int fio_start_gtod_thread(void); +extern struct timeval *fio_tv; + #endif diff --git a/t/stest.c b/t/stest.c index c1794843..0da8f2cf 100644 --- a/t/stest.c +++ b/t/stest.c @@ -6,6 +6,8 @@ #include "../flist.h" FILE *f_err; +struct timeval *fio_tv = NULL; +unsigned int fio_debug = 0; #define MAGIC1 0xa9b1c8d2 #define MAGIC2 0xf0a1e9b3 @@ -82,3 +84,7 @@ int main(int argc, char *argv[]) scleanup(); return 0; } + +void __dprint(int type, const char *str, ...) +{ +} diff --git a/time.c b/time.c index 4af84bc7..c4d1d4c7 100644 --- a/time.c +++ b/time.c @@ -6,72 +6,6 @@ static struct timeval genesis; static unsigned long ns_granularity; -unsigned long long utime_since(struct timeval *s, struct timeval *e) -{ - long sec, usec; - unsigned long long ret; - - sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; - if (sec > 0 && usec < 0) { - sec--; - usec += 1000000; - } - - /* - * time warp bug on some kernels? - */ - if (sec < 0 || (sec == 0 && usec < 0)) - return 0; - - ret = sec * 1000000ULL + usec; - - return ret; -} - -unsigned long long utime_since_now(struct timeval *s) -{ - struct timeval t; - - fio_gettime(&t, NULL); - return utime_since(s, &t); -} - -unsigned long mtime_since(struct timeval *s, struct timeval *e) -{ - long sec, usec, ret; - - sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; - if (sec > 0 && usec < 0) { - sec--; - usec += 1000000; - } - - if (sec < 0 || (sec == 0 && usec < 0)) - return 0; - - sec *= 1000UL; - usec /= 1000UL; - ret = sec + usec; - - return ret; -} - -unsigned long mtime_since_now(struct timeval *s) -{ - struct timeval t; - void *p = __builtin_return_address(0); - - fio_gettime(&t, p); - return mtime_since(s, &t); -} - -unsigned long time_since_now(struct timeval *s) -{ - return mtime_since_now(s) / 1000; -} - /* * busy looping version for the last few usec */ -- 2.25.1