glusterfs: update for new API

[fio.git] / t / read-to-pipe-async.c

diff --git a/t/read-to-pipe-async.c b/t/read-to-pipe-async.c
index 30a7631325bc0280326a73d91c24687665c6cdfa..ebdd8f1066f7c29588f620792ad12046838f0f8c 100644 (file)
--- a/t/read-to-pipe-async.c
+++ b/t/read-to-pipe-async.c
@@ -32,7 +32,6 @@
 #include <pthread.h>
 #include <errno.h>
 #include <assert.h>
-#include <time.h>
 
 #include "../flist.h"
 
@@ -231,6 +230,12 @@ static int write_work(struct work_item *work)
        return work->seq + 1;
 }
 
+static void thread_exiting(struct thread_data *thread)
+{
+       __sync_fetch_and_add(&thread->done, 1);
+       pthread_cond_signal(&thread->done_cond);
+}
+
 static void *writer_fn(void *data)
 {
        struct writer_thread *wt = data;
@@ -258,8 +263,7 @@ static void *writer_fn(void *data)
                        seq = write_work(work);
        }
 
-       wt->thread.done = 1;
-       pthread_cond_signal(&wt->thread.done_cond);
+       thread_exiting(&wt->thread);
        return NULL;
 }
 
@@ -361,14 +365,13 @@ static void *reader_fn(void *data)
                pthread_mutex_unlock(&rt->thread.lock);
 
                if (work) {
-                       rt->busy = 1;
+                       __sync_fetch_and_add(&rt->busy, 1);
                        reader_work(work);
-                       rt->busy = 0;
+                       __sync_fetch_and_sub(&rt->busy, 1);
                }
        }
 
-       rt->thread.done = 1;
-       pthread_cond_signal(&rt->thread.done_cond);
+       thread_exiting(&rt->thread);
        return NULL;
 }
 
@@ -469,20 +472,21 @@ static void exit_thread(struct thread_data *thread,
                        void fn(struct writer_thread *),
                        struct writer_thread *wt)
 {
-       thread->exit = 1;
+       __sync_fetch_and_add(&thread->exit, 1);
        pthread_cond_signal(&thread->cond);
 
        while (!thread->done) {
                pthread_mutex_lock(&thread->done_lock);
 
                if (fn) {
-                       struct timespec t;
-
-                       clock_gettime(CLOCK_REALTIME, &t);
-                       t.tv_sec++;
+                       struct timeval tv;
+                       struct timespec ts;
 
+                       gettimeofday(&tv, NULL);
+                       ts.tv_sec = tv.tv_sec + 1;
+                       ts.tv_nsec = tv.tv_usec * 1000ULL;
 
-                       pthread_cond_timedwait(&thread->done_cond, &thread->done_lock, &t);
+                       pthread_cond_timedwait(&thread->done_cond, &thread->done_lock, &ts);
                        fn(wt);
                } else
                        pthread_cond_wait(&thread->done_cond, &thread->done_lock);
@@ -606,7 +610,8 @@ int main(int argc, char *argv[])
        while (sb.st_size) {
                struct work_item *work;
                size_t this_len;
-               struct timespec t;
+               struct timespec ts;
+               struct timeval tv;
 
                prune_done_entries(wt);
 
@@ -627,15 +632,17 @@ int main(int argc, char *argv[])
 
                queue_work(rt, work);
 
-               clock_gettime(CLOCK_REALTIME, &t);
-               t.tv_nsec += max_us * 1000ULL;
-               if (t.tv_nsec >= 1000000000ULL) {
-                       t.tv_nsec -= 1000000000ULL;
-                       t.tv_sec++;
+               gettimeofday(&tv, NULL);
+               ts.tv_sec = tv.tv_sec;
+               ts.tv_nsec = tv.tv_usec * 1000ULL;
+               ts.tv_nsec += max_us * 1000ULL;
+               if (ts.tv_nsec >= 1000000000ULL) {
+                       ts.tv_nsec -= 1000000000ULL;
+                       ts.tv_sec++;
                }
 
                pthread_mutex_lock(&work->lock);
-               pthread_cond_timedwait(&work->cond, &work->lock, &t);
+               pthread_cond_timedwait(&work->cond, &work->lock, &ts);
                pthread_mutex_unlock(&work->lock);
 
                off += this_len;
@@ -654,9 +661,9 @@ int main(int argc, char *argv[])
 
        bytes /= 1024;
        rate = (bytes * 1000UL * 1000UL) / utime_since(&s, &re);
-       fprintf(stderr, "Read rate (KB/sec) : %lu\n", rate);
+       fprintf(stderr, "Read rate (KiB/sec) : %lu\n", rate);
        rate = (bytes * 1000UL * 1000UL) / utime_since(&s, &we);
-       fprintf(stderr, "Write rate (KB/sec): %lu\n", rate);
+       fprintf(stderr, "Write rate (KiB/sec): %lu\n", rate);
 
        close(fd);
        return 0;