replacing the pthread_mutex in scheduler_t with the wrapped implementation.
authorTobias Brunner <tobias@strongswan.org>
Tue, 25 Nov 2008 19:30:02 +0000 (19:30 -0000)
committerTobias Brunner <tobias@strongswan.org>
Tue, 25 Nov 2008 19:30:02 +0000 (19:30 -0000)
added a method to condvar_t which allows to wait for an absolute timeout.

src/charon/processing/scheduler.c
src/libstrongswan/utils/mutex.c
src/libstrongswan/utils/mutex.h

index bbf1dc1..4a8089d 100644 (file)
@@ -25,6 +25,7 @@
 #include <daemon.h>
 #include <processing/processor.h>
 #include <processing/jobs/callback_job.h>
+#include <utils/mutex.h>
 
 typedef struct event_t event_t;
 
@@ -76,14 +77,12 @@ struct private_scheduler_t {
        /**
         * Exclusive access to list
         */
-       pthread_mutex_t mutex;
+       mutex_t *mutex;
 
        /**
         * Condvar to wait for next job.
         */
-       pthread_cond_t condvar;
-       
-       bool cancelled;
+       condvar_t *condvar;
 };
 
 /**
@@ -104,7 +103,6 @@ static long time_difference(timeval_t *end, timeval_t *start)
  */
 static job_requeue_t schedule(private_scheduler_t * this)
 {
-       timespec_t timeout;
        timeval_t now;
        event_t *event;
        long difference;
@@ -112,7 +110,7 @@ static job_requeue_t schedule(private_scheduler_t * this)
        bool timed = FALSE;
        
        DBG2(DBG_JOB, "waiting for next event...");
-       pthread_mutex_lock(&this->mutex);
+       this->mutex->lock(this->mutex);
        
        gettimeofday(&now, NULL);
        
@@ -122,27 +120,25 @@ static job_requeue_t schedule(private_scheduler_t * this)
                difference = time_difference(&now, &event->time);
                if (difference > 0)
                {
-                       DBG2(DBG_JOB, "got event, queueing job for execution");
                        this->list->remove_first(this->list, (void **)&event);  
-                       pthread_mutex_unlock(&this->mutex);
+                       this->mutex->unlock(this->mutex);
+                       DBG2(DBG_JOB, "got event, queueing job for execution");
                        charon->processor->queue_job(charon->processor, event->job);
                        free(event);
                        return JOB_REQUEUE_DIRECT;
                }
-               timeout.tv_sec = event->time.tv_sec;
-               timeout.tv_nsec = event->time.tv_usec * 1000;
                timed = TRUE;
        }
-       pthread_cleanup_push((void*)pthread_mutex_unlock, &this->mutex);
+       pthread_cleanup_push((void*)this->mutex->unlock, this->mutex);
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
        
        if (timed)
        {
-               pthread_cond_timedwait(&this->condvar, &this->mutex, &timeout);
+               this->condvar->timed_wait_abs(this->condvar, this->mutex, event->time);
        }
        else
        {
-               pthread_cond_wait(&this->condvar, &this->mutex);
+               this->condvar->wait(this->condvar, this->mutex);
        }
        pthread_setcancelstate(oldstate, NULL);
        pthread_cleanup_pop(TRUE);
@@ -155,9 +151,9 @@ static job_requeue_t schedule(private_scheduler_t * this)
 static u_int get_job_load(private_scheduler_t *this)
 {
        int count;
-       pthread_mutex_lock(&this->mutex);
+       this->mutex->lock(this->mutex);
        count = this->list->get_count(this->list);
-       pthread_mutex_unlock(&this->mutex);
+       this->mutex->unlock(this->mutex);
        return count;
 }
 
@@ -182,7 +178,7 @@ static void schedule_job(private_scheduler_t *this, job_t *job, u_int32_t time)
        event->time.tv_usec = (now.tv_usec + us) % 1000000;
        event->time.tv_sec = now.tv_sec + (now.tv_usec + us)/1000000 + s;
        
-       pthread_mutex_lock(&this->mutex);
+       this->mutex->lock(this->mutex);
        while(TRUE)
        {
                if (this->list->get_count(this->list) == 0)
@@ -220,8 +216,8 @@ static void schedule_job(private_scheduler_t *this, job_t *job, u_int32_t time)
                iterator->destroy(iterator);
                break;
        }
-       pthread_cond_signal(&this->condvar);
-       pthread_mutex_unlock(&this->mutex);
+       this->condvar->signal(this->condvar);
+       this->mutex->unlock(this->mutex);
 }
 
 /**
@@ -229,8 +225,9 @@ static void schedule_job(private_scheduler_t *this, job_t *job, u_int32_t time)
  */
 static void destroy(private_scheduler_t *this)
 {
-       this->cancelled = TRUE;
        this->job->cancel(this->job);
+       this->condvar->destroy(this->condvar);
+       this->mutex->destroy(this->mutex);
        this->list->destroy_function(this->list, (void*)event_destroy);
        free(this);
 }
@@ -247,9 +244,8 @@ scheduler_t * scheduler_create()
        this->public.destroy = (void(*)(scheduler_t*)) destroy;
        
        this->list = linked_list_create();
-       this->cancelled = FALSE;
-       pthread_mutex_init(&this->mutex, NULL);
-       pthread_cond_init(&this->condvar, NULL);
+       this->mutex = mutex_create(MUTEX_DEFAULT);
+       this->condvar = condvar_create(CONDVAR_DEFAULT);
        
        this->job = callback_job_create((callback_job_cb_t)schedule, this, NULL, NULL);
        charon->processor->queue_job(charon->processor, (job_t*)this->job);
index 3dc274e..cb6940d 100644 (file)
@@ -1,4 +1,5 @@
 /*
+ * Copyright (C) 2008 Tobias Brunner
  * Copyright (C) 2008 Martin Willi
  * Hochschule fuer Technik Rapperswil
  *
@@ -332,28 +333,17 @@ static void wait(private_condvar_t *this, private_mutex_t *mutex)
 }
 
 /**
- * Implementation of condvar_t.timed_wait.
+ * Implementation of condvar_t.timed_wait_abs.
  */
-static bool timed_wait(private_condvar_t *this, private_mutex_t *mutex,
-                                          u_int timeout)
+static bool timed_wait_abs(private_condvar_t *this, private_mutex_t *mutex,
+                                                  timeval_t time)
 {
        struct timespec ts;
-       struct timeval tv;
-       u_int s, ms;
        bool timed_out;
        
-       gettimeofday(&tv, NULL);
-       
-       s = timeout / 1000;
-       ms = timeout % 1000;
+       ts.tv_sec = time.tv_sec;
+       ts.tv_nsec = time.tv_usec * 1000;
        
-       ts.tv_sec = tv.tv_sec + s;
-       ts.tv_nsec = tv.tv_usec * 1000 + ms * 1000000;
-       if (ts.tv_nsec > 1000000000 /* 1s */)
-       {
-               ts.tv_nsec -= 1000000000;
-               ts.tv_sec++;
-       }
        if (mutex->recursive)
        {
                private_r_mutex_t* recursive = (private_r_mutex_t*)mutex;
@@ -372,6 +362,31 @@ static bool timed_wait(private_condvar_t *this, private_mutex_t *mutex,
 }
 
 /**
+ * Implementation of condvar_t.timed_wait.
+ */
+static bool timed_wait(private_condvar_t *this, private_mutex_t *mutex,
+                                          u_int timeout)
+{
+       timeval_t tv;
+       u_int s, ms;
+       
+       gettimeofday(&tv, NULL);
+       
+       s = timeout / 1000;
+       ms = timeout % 1000;
+       
+       tv.tv_sec += s;
+       tv.tv_usec += ms * 1000;
+       
+       if (tv.tv_usec > 1000000 /* 1s */)
+       {
+               tv.tv_usec -= 1000000;
+               tv.tv_sec++;
+       }
+       return timed_wait_abs(this, mutex, tv);
+}
+
+/**
  * Implementation of condvar_t.signal.
  */
 static void signal(private_condvar_t *this)
@@ -410,6 +425,7 @@ condvar_t *condvar_create(condvar_type_t type)
                
                        this->public.wait = (void(*)(condvar_t*, mutex_t *mutex))wait;
                        this->public.timed_wait = (bool(*)(condvar_t*, mutex_t *mutex, u_int timeout))timed_wait;
+                       this->public.timed_wait_abs = (bool(*)(condvar_t*, mutex_t *mutex, timeval_t time))timed_wait_abs;
                        this->public.signal = (void(*)(condvar_t*))signal;
                        this->public.broadcast = (void(*)(condvar_t*))broadcast;
                        this->public.destroy = (void(*)(condvar_t*))condvar_destroy;
index a0a1980..1aadb71 100644 (file)
@@ -1,4 +1,5 @@
 /*
+ * Copyright (C) 2008 Tobias Brunner
  * Copyright (C) 2008 Martin Willi
  * Hochschule fuer Technik Rapperswil
  *
@@ -11,6 +12,8 @@
  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * for more details.
+ * 
+ * $Id$
  */
 
 /**
@@ -99,6 +102,15 @@ struct condvar_t {
        bool (*timed_wait)(condvar_t *this, mutex_t *mutex, u_int timeout);
        
        /**
+        * Wait on a condvar until it gets signalized, or times out.
+        * 
+        * @param mutex                 mutex to release while waiting
+        * @param time                  absolute time until timeout
+        * @return                              TRUE if timed out, FALSE otherwise
+        */
+       bool (*timed_wait_abs)(condvar_t *this, mutex_t *mutex, timeval_t timeout);
+       
+       /**
         * Wake up a single thread in a condvar.
         */
        void (*signal)(condvar_t *this);