From 6df2731e7847d65f3aceef2a24c6e8548839b5e8 Mon Sep 17 00:00:00 2001 From: Tobias Brunner Date: Tue, 25 Nov 2008 19:30:02 +0000 Subject: [PATCH] replacing the pthread_mutex in scheduler_t with the wrapped implementation. added a method to condvar_t which allows to wait for an absolute timeout. --- src/charon/processing/scheduler.c | 40 +++++++++++++++----------------- src/libstrongswan/utils/mutex.c | 48 ++++++++++++++++++++++++++------------- src/libstrongswan/utils/mutex.h | 12 ++++++++++ 3 files changed, 62 insertions(+), 38 deletions(-) diff --git a/src/charon/processing/scheduler.c b/src/charon/processing/scheduler.c index bbf1dc1..4a8089d 100644 --- a/src/charon/processing/scheduler.c +++ b/src/charon/processing/scheduler.c @@ -25,6 +25,7 @@ #include #include #include +#include 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); diff --git a/src/libstrongswan/utils/mutex.c b/src/libstrongswan/utils/mutex.c index 3dc274e..cb6940d 100644 --- a/src/libstrongswan/utils/mutex.c +++ b/src/libstrongswan/utils/mutex.c @@ -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; diff --git a/src/libstrongswan/utils/mutex.h b/src/libstrongswan/utils/mutex.h index a0a1980..1aadb71 100644 --- a/src/libstrongswan/utils/mutex.h +++ b/src/libstrongswan/utils/mutex.h @@ -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); -- 2.7.4