From c23b3b9bf9ba49de5c83a32daa3eb381b9c19415 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Florian=20M=C3=A4rkl?= Date: Tue, 25 Jun 2019 12:40:31 +0200 Subject: [PATCH] Refactor ChiakiPredCond to ChiakiBoolPredCond --- lib/include/chiaki/congestioncontrol.h | 2 +- lib/include/chiaki/streamconnection.h | 2 +- lib/include/chiaki/thread.h | 25 ++++---- lib/src/congestioncontrol.c | 14 ++--- lib/src/streamconnection.c | 10 +-- lib/src/thread.c | 86 ++++++++++++++++---------- 6 files changed, 80 insertions(+), 59 deletions(-) diff --git a/lib/include/chiaki/congestioncontrol.h b/lib/include/chiaki/congestioncontrol.h index ae41509..39c2b85 100644 --- a/lib/include/chiaki/congestioncontrol.h +++ b/lib/include/chiaki/congestioncontrol.h @@ -29,7 +29,7 @@ typedef struct chiaki_congestion_control_t { ChiakiTakion *takion; ChiakiThread thread; - ChiakiPredCond stop_cond; + ChiakiBoolPredCond stop_cond; } ChiakiCongestionControl; CHIAKI_EXPORT ChiakiErrorCode chiaki_congestion_control_start(ChiakiCongestionControl *control, ChiakiTakion *takion); diff --git a/lib/include/chiaki/streamconnection.h b/lib/include/chiaki/streamconnection.h index 2f692ff..cf86a50 100644 --- a/lib/include/chiaki/streamconnection.h +++ b/lib/include/chiaki/streamconnection.h @@ -39,7 +39,7 @@ typedef struct chiaki_stream_connection_t uint8_t *ecdh_secret; ChiakiGKCrypt *gkcrypt_local; ChiakiGKCrypt *gkcrypt_remote; - ChiakiPredCond stop_cond; + ChiakiBoolPredCond stop_cond; } ChiakiStreamConnection; CHIAKI_EXPORT ChiakiErrorCode chiaki_stream_connection_run(struct chiaki_session_t *session); diff --git a/lib/include/chiaki/thread.h b/lib/include/chiaki/thread.h index 92ba7eb..29803c4 100644 --- a/lib/include/chiaki/thread.h +++ b/lib/include/chiaki/thread.h @@ -56,30 +56,33 @@ typedef struct chiaki_cond_t pthread_cond_t cond; } ChiakiCond; +typedef bool (*ChiakiCheckPred)(void *); + CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_init(ChiakiCond *cond); CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_fini(ChiakiCond *cond); CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_wait(ChiakiCond *cond, ChiakiMutex *mutex); CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_timedwait(ChiakiCond *cond, ChiakiMutex *mutex, uint64_t timeout_ms); +CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_wait_pred(ChiakiCond *cond, ChiakiMutex *mutex, ChiakiCheckPred check_pred, void *check_pred_user); +CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_timedwait_pred(ChiakiCond *cond, ChiakiMutex *mutex, uint64_t timeout_ms, ChiakiCheckPred check_pred, void *check_pred_user); CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_signal(ChiakiCond *cond); CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_broadcast(ChiakiCond *cond); -typedef struct chiaki_pred_cond_t +typedef struct chiaki_bool_pred_cond_t { ChiakiCond cond; ChiakiMutex mutex; bool pred; -} ChiakiPredCond; +} ChiakiBoolPredCond; -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_init(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_fini(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_lock(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_unlock(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_wait(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_timedwait(ChiakiPredCond *cond, uint64_t timeout_ms); -CHIAKI_EXPORT void chiaki_pred_cond_reset(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_signal(ChiakiPredCond *cond); -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_broadcast(ChiakiPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_init(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_fini(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_lock(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_unlock(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_wait(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_timedwait(ChiakiBoolPredCond *cond, uint64_t timeout_ms); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_signal(ChiakiBoolPredCond *cond); +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_broadcast(ChiakiBoolPredCond *cond); #ifdef __cplusplus } diff --git a/lib/src/congestioncontrol.c b/lib/src/congestioncontrol.c index 6185648..77e0972 100644 --- a/lib/src/congestioncontrol.c +++ b/lib/src/congestioncontrol.c @@ -25,13 +25,13 @@ static void *congestion_control_thread_func(void *user) { ChiakiCongestionControl *control = user; - ChiakiErrorCode err = chiaki_pred_cond_lock(&control->stop_cond); + ChiakiErrorCode err = chiaki_bool_pred_cond_lock(&control->stop_cond); if(err != CHIAKI_ERR_SUCCESS) return NULL; while(true) { - err = chiaki_pred_cond_timedwait(&control->stop_cond, CONGESTION_CONTROL_INTERVAL_MS); + err = chiaki_bool_pred_cond_timedwait(&control->stop_cond, CONGESTION_CONTROL_INTERVAL_MS); if(err != CHIAKI_ERR_TIMEOUT) break; @@ -40,7 +40,7 @@ static void *congestion_control_thread_func(void *user) chiaki_takion_send_congestion(control->takion, &packet); } - chiaki_pred_cond_unlock(&control->stop_cond); + chiaki_bool_pred_cond_unlock(&control->stop_cond); return NULL; } @@ -48,14 +48,14 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_congestion_control_start(ChiakiCongestionCo { control->takion = takion; - ChiakiErrorCode err = chiaki_pred_cond_init(&control->stop_cond); + ChiakiErrorCode err = chiaki_bool_pred_cond_init(&control->stop_cond); if(err != CHIAKI_ERR_SUCCESS) return err; err = chiaki_thread_create(&control->thread, congestion_control_thread_func, control); if(err != CHIAKI_ERR_SUCCESS) { - chiaki_pred_cond_fini(&control->stop_cond); + chiaki_bool_pred_cond_fini(&control->stop_cond); return err; } @@ -64,7 +64,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_congestion_control_start(ChiakiCongestionCo CHIAKI_EXPORT ChiakiErrorCode chiaki_congestion_control_stop(ChiakiCongestionControl *control) { - ChiakiErrorCode err = chiaki_pred_cond_signal(&control->stop_cond); + ChiakiErrorCode err = chiaki_bool_pred_cond_signal(&control->stop_cond); if(err != CHIAKI_ERR_SUCCESS) return err; @@ -72,5 +72,5 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_congestion_control_stop(ChiakiCongestionCon if(err != CHIAKI_ERR_SUCCESS) return err; - return chiaki_pred_cond_fini(&control->stop_cond); + return chiaki_bool_pred_cond_fini(&control->stop_cond); } diff --git a/lib/src/streamconnection.c b/lib/src/streamconnection.c index 0cf8483..ab13b15 100644 --- a/lib/src/streamconnection.c +++ b/lib/src/streamconnection.c @@ -74,7 +74,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_stream_connection_run(ChiakiSession *sessio stream_connection->ecdh_secret = NULL; - ChiakiErrorCode err = chiaki_pred_cond_init(&stream_connection->stop_cond); + ChiakiErrorCode err = chiaki_bool_pred_cond_init(&stream_connection->stop_cond); if(err != CHIAKI_ERR_SUCCESS) goto error; @@ -177,12 +177,12 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_stream_connection_run(ChiakiSession *sessio CHIAKI_LOGI(&session->log, "StreamConnection successfully received streaminfo\n"); - err = chiaki_pred_cond_lock(&stream_connection->stop_cond); + err = chiaki_bool_pred_cond_lock(&stream_connection->stop_cond); assert(err == CHIAKI_ERR_SUCCESS); while(true) { - err = chiaki_pred_cond_timedwait(&stream_connection->stop_cond, HEARTBEAT_INTERVAL_MS); + err = chiaki_bool_pred_cond_timedwait(&stream_connection->stop_cond, HEARTBEAT_INTERVAL_MS); if(err != CHIAKI_ERR_TIMEOUT) break; @@ -193,7 +193,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_stream_connection_run(ChiakiSession *sessio CHIAKI_LOGI(stream_connection->log, "StreamConnection sent heartbeat\n"); } - err = chiaki_pred_cond_unlock(&stream_connection->stop_cond); + err = chiaki_bool_pred_cond_unlock(&stream_connection->stop_cond); assert(err == CHIAKI_ERR_SUCCESS); CHIAKI_LOGI(&session->log, "StreamConnection is disconnecting\n"); @@ -212,7 +212,7 @@ error_takion: error_mirai: chiaki_mirai_fini(&stream_connection->mirai); error_stop_cond: - chiaki_pred_cond_fini(&stream_connection->stop_cond); + chiaki_bool_pred_cond_fini(&stream_connection->stop_cond); error: free(stream_connection->ecdh_secret); return err; diff --git a/lib/src/thread.c b/lib/src/thread.c index 4c7c1d1..38594cb 100644 --- a/lib/src/thread.c +++ b/lib/src/thread.c @@ -155,6 +155,32 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_timedwait(ChiakiCond *cond, ChiakiMute return chiaki_cond_timedwait_abs(cond, mutex, &timeout); } +CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_wait_pred(ChiakiCond *cond, ChiakiMutex *mutex, ChiakiCheckPred check_pred, void *check_pred_user) +{ + while(!check_pred(check_pred_user)) + { + ChiakiErrorCode err = chiaki_cond_wait(cond, mutex); + if(err != CHIAKI_ERR_SUCCESS) + return err; + } + return CHIAKI_ERR_SUCCESS; + +} + +CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_timedwait_pred(ChiakiCond *cond, ChiakiMutex *mutex, uint64_t timeout_ms, ChiakiCheckPred check_pred, void *check_pred_user) +{ + struct timespec timeout; + set_timeout(&timeout, timeout_ms); + while(!check_pred(check_pred_user)) + { + ChiakiErrorCode err = chiaki_cond_timedwait_abs(cond, mutex, &timeout); + if(err != CHIAKI_ERR_SUCCESS) + return err; + } + return CHIAKI_ERR_SUCCESS; + +} + CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_signal(ChiakiCond *cond) { int r = pthread_cond_signal(&cond->cond); @@ -174,7 +200,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_cond_broadcast(ChiakiCond *cond) -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_init(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_init(ChiakiBoolPredCond *cond) { cond->pred = false; @@ -192,7 +218,7 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_init(ChiakiPredCond *cond) return CHIAKI_ERR_SUCCESS; } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_fini(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_fini(ChiakiBoolPredCond *cond) { ChiakiErrorCode err = chiaki_cond_fini(&cond->cond); if(err != CHIAKI_ERR_SUCCESS) @@ -205,67 +231,59 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_fini(ChiakiPredCond *cond) return CHIAKI_ERR_SUCCESS; } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_lock(ChiakiPredCond *cond) + +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_lock(ChiakiBoolPredCond *cond) { return chiaki_mutex_lock(&cond->mutex); } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_unlock(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_unlock(ChiakiBoolPredCond *cond) { return chiaki_mutex_unlock(&cond->mutex); } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_wait(ChiakiPredCond *cond) +bool bool_pred_cond_check_pred(void *user) { - while(!cond->pred) - { - ChiakiErrorCode err = chiaki_cond_wait(&cond->cond, &cond->mutex); - if(err != CHIAKI_ERR_SUCCESS) - return err; - } - return CHIAKI_ERR_SUCCESS; + ChiakiBoolPredCond *bool_pred_cond = user; + return bool_pred_cond->pred; } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_timedwait(ChiakiPredCond *cond, uint64_t timeout_ms) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_wait(ChiakiBoolPredCond *cond) { - struct timespec timeout; - set_timeout(&timeout, timeout_ms); - while(!cond->pred) - { - ChiakiErrorCode err = chiaki_cond_timedwait_abs(&cond->cond, &cond->mutex, &timeout); - if(err != CHIAKI_ERR_SUCCESS) - return err; - } - return CHIAKI_ERR_SUCCESS; + return chiaki_cond_wait_pred(&cond->cond, &cond->mutex, bool_pred_cond_check_pred, cond); } -CHIAKI_EXPORT void chiaki_pred_cond_reset(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_timedwait(ChiakiBoolPredCond *cond, uint64_t timeout_ms) { - cond->pred = false; + return chiaki_cond_timedwait_pred(&cond->cond, &cond->mutex, timeout_ms, bool_pred_cond_check_pred, cond); } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_signal(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_signal(ChiakiBoolPredCond *cond) { - ChiakiErrorCode err = chiaki_mutex_lock(&cond->mutex); + ChiakiErrorCode err = chiaki_bool_pred_cond_lock(cond); if(err != CHIAKI_ERR_SUCCESS) return err; cond->pred = true; - err = chiaki_cond_signal(&cond->cond); - ChiakiErrorCode unlock_err = chiaki_mutex_unlock(&cond->mutex); - return err == CHIAKI_ERR_SUCCESS ? unlock_err : err; + err = chiaki_bool_pred_cond_unlock(cond); + if(err != CHIAKI_ERR_SUCCESS) + return err; + + return chiaki_cond_signal(&cond->cond); } -CHIAKI_EXPORT ChiakiErrorCode chiaki_pred_cond_broadcast(ChiakiPredCond *cond) +CHIAKI_EXPORT ChiakiErrorCode chiaki_bool_pred_cond_broadcast(ChiakiBoolPredCond *cond) { - ChiakiErrorCode err = chiaki_mutex_lock(&cond->mutex); + ChiakiErrorCode err = chiaki_bool_pred_cond_lock(cond); if(err != CHIAKI_ERR_SUCCESS) return err; cond->pred = true; - err = chiaki_cond_broadcast(&cond->cond); - ChiakiErrorCode unlock_err = chiaki_mutex_unlock(&cond->mutex); - return err == CHIAKI_ERR_SUCCESS ? unlock_err : err; + err = chiaki_bool_pred_cond_unlock(cond); + if(err != CHIAKI_ERR_SUCCESS) + return err; + + return chiaki_cond_broadcast(&cond->cond); }