#if HAVE_CRT
#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>
#endif //HAVE_CRT
/*
* Copyright (C) 2020, University of the Basque Country (UPV/EHU)
* Contact for licensing options: <licensing-mcpttclient(at)mcopenplatform(dot)com>
*
* The original file was part of Open Source Doubango Framework
* Copyright (C) 2010-2011 Mamadou Diop.
* Copyright (C) 2012 Doubango Telecom <http://doubango.org>
*
* This file is part of Open Source Doubango Framework.
*
* DOUBANGO is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* DOUBANGO is distributed in the hope that it will be useful,
* but 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.
*
* You should have received a copy of the GNU General Public License
* along with DOUBANGO.
*
*/
/**@file tsk_timer.c
* @brief Timer Manager.
*
* @author Mamadou Diop <diopmamadou(at)doubango[dot]org>
*
* @date Created: Sat Nov 8 16:54:58 2009 mdiop
*/
#include "tsk_timer.h"
#include "tsk_debug.h"
#include "tsk_list.h"
#include "tsk_thread.h"
#include "tsk_runnable.h"
#include "tsk_condwait.h"
#include "tsk_semaphore.h"
#include "tsk_time.h"
#if TSK_UNDER_WINDOWS
# include <windows.h>
#endif /* TSK_UNDER_WINDOWS */
/**@defgroup tsk_timer_group Timers Management
*/
#define TSK_TIMER_CREATE(timeout, callback, arg) tsk_object_new(tsk_timer_def_t, timeout, callback, arg)
#define TSK_TIMER_TIMEOUT(self) ((tsk_timer_t*)self)->timeout
#define TSK_TIMER_GET_FIRST() (manager->timers && manager->timers->head) ? (tsk_timer_t*)(((tsk_list_item_t*)(manager->timers->head))->data) : 0
/**
* @struct tsk_timer_s
* @brief Timer.
**/
typedef struct tsk_timer_s
{
TSK_DECLARE_OBJECT;
tsk_timer_id_t id; /**< Unique timer identifier. */
const void *arg; /**< Opaque data to return with the callback function. */
uint64_t timeout; /**< When the timer will timeout(as EPOCH time). */
tsk_timer_callback_f callback; /**< The callback function to call after @ref timeout milliseconds. */
unsigned canceled:1;
}
tsk_timer_t;
typedef tsk_list_t tsk_timers_L_t; /**< List of @ref tsk_timer_t elements. */
/**
* @struct tsk_timer_manager_s
*
* @brief Timer manager.
**/
typedef struct tsk_timer_manager_s
{
TSK_DECLARE_RUNNABLE;
void* mainThreadId[1];
tsk_condwait_handle_t *condwait;
tsk_mutex_handle_t *mutex;
tsk_semaphore_handle_t *sem;
tsk_timers_L_t *timers;
}
tsk_timer_manager_t;
typedef tsk_list_t tsk_timer_manager_L_t; /**< List of @ref tsk_timer_manager_t elements. */
/*== Definitions */
static void* TSK_STDCALL __tsk_timer_manager_mainthread(void *param);
static int __tsk_pred_find_timer_by_id(const tsk_list_item_t *item, const void *id);
static void __tsk_timer_manager_raise(tsk_timer_t *timer);
static void* TSK_STDCALL run(void* self);
/**@ingroup tsk_timer_group
*/
tsk_timer_manager_handle_t* tsk_timer_manager_create()
{
return tsk_object_new(tsk_timer_manager_def_t);
}
/**@ingroup tsk_timer_group
* Starts the timer manager.
*/
int tsk_timer_manager_start(tsk_timer_manager_handle_t *self)
{
int err = -1;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
TSK_DEBUG_INFO("tsk_timer_manager_start");
if(!manager){
return -1;
}
tsk_mutex_lock(manager->mutex);
if(!TSK_RUNNABLE(manager)->running && !TSK_RUNNABLE(manager)->started){
TSK_RUNNABLE(manager)->run = run;
if((err = tsk_runnable_start(TSK_RUNNABLE(manager), tsk_timer_def_t))){
//TSK_OBJECT_SAFE_FREE(manager);
goto bail;
}
}
else{
TSK_DEBUG_INFO("Timer manager already running");
err = 0;
}
bail:
tsk_mutex_unlock(manager->mutex);
return err;
}
#if defined(DEBUG) || defined(_DEBUG) || !defined(NDEBUG)
/**@ingroup tsk_timer_group
*/
void tsk_timer_manager_debug(tsk_timer_manager_handle_t *self)
{
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
if(manager){
//int index = 0;
tsk_list_item_t *item = tsk_null;
tsk_mutex_lock(manager->mutex);
tsk_list_foreach(item, manager->timers){
tsk_timer_t* timer = (tsk_timer_t*)item->data;
TSK_DEBUG_INFO("timer [%llu]- %llu, %llu", (uint64_t)timer->id, timer->timeout, tsk_time_now());
}
tsk_mutex_unlock(manager->mutex);
}
}
#endif
/**@ingroup tsk_timer_group
*/
int tsk_timer_manager_stop(tsk_timer_manager_handle_t *self)
{
int ret = -1;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
if(!manager){
TSK_DEBUG_ERROR("Invalid paramater");
return -1;
}
// all functions called below are thread-safe ==> do not lock
// "mainthread" uses manager->mutex and runs in a separate thread ==> deadlock
if(TSK_RUNNABLE(manager)->running){
if((ret = tsk_runnable_stop(TSK_RUNNABLE(manager)))){
goto bail;
}
tsk_semaphore_increment(manager->sem);
tsk_condwait_signal(manager->condwait);
ret = tsk_thread_join(manager->mainThreadId);
goto bail;
}
else{
ret = 0; /* already running. */
goto bail;
}
bail:
tsk_list_clear_items(manager->timers);
return ret;
}
/**@ingroup tsk_timer_group
*/
tsk_timer_id_t tsk_timer_manager_schedule(tsk_timer_manager_handle_t *self, uint64_t timeout, tsk_timer_callback_f callback, const void *arg)
{
tsk_timer_id_t timer_id = TSK_INVALID_TIMER_ID;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
if(manager && (TSK_RUNNABLE(manager)->running || TSK_RUNNABLE(manager)->started)){
tsk_timer_t *timer;
timer = (tsk_timer_t*)TSK_TIMER_CREATE(timeout, callback, arg);
timer_id = timer->id;
tsk_mutex_lock(manager->mutex);
tsk_list_push_ascending_data(manager->timers, ((void**) &timer));
tsk_mutex_unlock(manager->mutex);
// tsk_timer_manager_debug(self);
tsk_condwait_signal(manager->condwait);
tsk_semaphore_increment(manager->sem);
}
return timer_id;
}
/**@ingroup tsk_timer_group
*/
int tsk_timer_manager_cancel(tsk_timer_manager_handle_t *self, tsk_timer_id_t id)
{
int ret = -1;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
/* Check validity. */
if(!TSK_TIMER_ID_IS_VALID(id)){ /* Very common. */
return 0;
}
if(!TSK_LIST_IS_EMPTY(manager->timers) && TSK_RUNNABLE(manager)->running){
const tsk_list_item_t *item;
tsk_mutex_lock(manager->mutex);
item = tsk_list_find_item_by_pred(manager->timers, __tsk_pred_find_timer_by_id, &id);
if(item && item->data){
tsk_timer_t *timer = (tsk_timer_t*)item->data;
timer->canceled = 1;
timer->callback = tsk_null;
if(item == manager->timers->head){
/* The timer we are waiting on ? ==> remove it now. */
tsk_condwait_signal(manager->condwait);
}
ret = 0;
}
tsk_mutex_unlock(manager->mutex);
}
return ret;
}
int tsk_timer_manager_destroy(tsk_timer_manager_handle_t **self)
{
if(!self || !*self){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
TSK_OBJECT_SAFE_FREE(*self);
return 0;
}
static void* TSK_STDCALL run(void* self)
{
int ret;
tsk_list_item_t *curr;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
TSK_RUNNABLE(manager)->running = tsk_true; // VERY IMPORTANT --> needed by the main thread
/* create main thread */
if((ret = tsk_thread_create(&(manager->mainThreadId[0]), __tsk_timer_manager_mainthread, manager))){
TSK_DEBUG_FATAL("Failed to create mainthread: %d\n", ret);
return tsk_null;
}
TSK_DEBUG_INFO("Timer manager run()::enter");
TSK_RUNNABLE_RUN_BEGIN(manager);
if((curr = TSK_RUNNABLE_POP_FIRST_SAFE(TSK_RUNNABLE(manager)))){
tsk_timer_t *timer = (tsk_timer_t *)curr->data;
if(timer->callback){
timer->callback(timer->arg, timer->id);
}
tsk_object_unref(curr);
}
TSK_RUNNABLE_RUN_END(manager);
TSK_DEBUG_INFO("Timer manager run()::exit");
return tsk_null;
}
static int __tsk_pred_find_timer_by_id(const tsk_list_item_t *item, const void *id)
{
tsk_timer_t *timer;
if(item && item->data){
timer = (tsk_timer_t*)item->data;
return (int)(timer->id - *((tsk_timer_id_t*)id));
}
return -1;
}
static void* TSK_STDCALL __tsk_timer_manager_mainthread(void *param)
{
int ret;
tsk_timer_t *curr;
uint64_t now;
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)param;
TSK_DEBUG_INFO("TIMER MANAGER -- START");
while(TSK_RUNNABLE(manager)->running){
tsk_semaphore_decrement(manager->sem);
peek_first:
if(!TSK_RUNNABLE(manager)->running){
break;
}
tsk_mutex_lock(manager->mutex);
curr = TSK_TIMER_GET_FIRST();
tsk_mutex_unlock(manager->mutex);
if (curr && !curr->canceled) {
now = tsk_time_now();
if (now >= curr->timeout) {
tsk_timer_t *timer = (tsk_timer_t*)tsk_object_ref(curr);
//TSK_DEBUG_INFO("Timer raise %llu", timer->id);
tsk_mutex_lock(manager->mutex); // must lock() before enqueue()
TSK_RUNNABLE_ENQUEUE_OBJECT_SAFE(TSK_RUNNABLE(manager), timer);
tsk_list_remove_item_by_data(manager->timers, curr);
tsk_mutex_unlock(manager->mutex);
TSK_OBJECT_SAFE_FREE(timer);
}
else{
if((ret = tsk_condwait_timedwait(manager->condwait, (curr->timeout - now)))){
TSK_DEBUG_ERROR("CONWAIT for timer manager failed [%d]", ret);
break;
}
else{
goto peek_first;
}
}
}
else if(curr) {
tsk_mutex_lock(manager->mutex);
/* TSK_DEBUG_INFO("Timer canceled %llu", curr->id); */
tsk_list_remove_item_by_data(manager->timers, curr);
tsk_mutex_unlock(manager->mutex);
}
} /* while() */
TSK_DEBUG_INFO("TIMER MANAGER -- STOP");
return tsk_null;
}
/* ================= Global Timer Manager ================= */
static tsk_timer_manager_t* __timer_mgr = tsk_null;
tsk_timer_manager_handle_t* tsk_timer_mgr_global_ref()
{
if(!__timer_mgr){
__timer_mgr = (tsk_timer_manager_t*)tsk_timer_manager_create();
}
else{
__timer_mgr = (tsk_timer_manager_t*)tsk_object_ref(__timer_mgr);
}
return __timer_mgr;
}
int tsk_timer_mgr_global_start()
{
int ret = 0;
if(!__timer_mgr){
TSK_DEBUG_ERROR("No global Timer manager could be found");
return -1;
}
if(!TSK_RUNNABLE(__timer_mgr)->running && !TSK_RUNNABLE(__timer_mgr)->started){
if((ret = tsk_timer_manager_start(__timer_mgr))){
return ret;
}
}
tsk_mutex_lock(__timer_mgr->mutex);
tsk_mutex_unlock(__timer_mgr->mutex);
return ret;
}
tsk_timer_id_t tsk_timer_mgr_global_schedule(uint64_t timeout, tsk_timer_callback_f callback, const void *arg)
{
if(!__timer_mgr){
TSK_DEBUG_ERROR("No global Timer manager could be found");
return TSK_INVALID_TIMER_ID;
}
return tsk_timer_manager_schedule(__timer_mgr, timeout, callback, arg);
}
int tsk_timer_mgr_global_cancel(tsk_timer_id_t id)
{
if(!__timer_mgr){
TSK_DEBUG_ERROR("No global Timer manager could be found");
return -1;
}
return tsk_timer_manager_cancel(__timer_mgr, id);
}
int tsk_timer_mgr_global_unref(tsk_timer_manager_handle_t** mgr_global)
{
if(!mgr_global || !*mgr_global){
return 0;
}
if((*mgr_global != __timer_mgr)){
TSK_DEBUG_ERROR("Invalid parameter");
return -1;
}
__timer_mgr = (tsk_timer_manager_t*)tsk_object_unref(TSK_OBJECT(*mgr_global));
*mgr_global = tsk_null;
return 0;
}
//=================================================================================================
// Timer manager object definition
//
static tsk_object_t* tsk_timer_manager_ctor(tsk_object_t * self, va_list * app)
{
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
if(manager){
manager->timers = tsk_list_create();
manager->sem = tsk_semaphore_create();
manager->condwait = tsk_condwait_create();
manager->mutex = tsk_mutex_create();
}
return self;
}
static tsk_object_t* tsk_timer_manager_dtor(tsk_object_t * self)
{
tsk_timer_manager_t *manager = (tsk_timer_manager_t*)self;
if(manager){
tsk_timer_manager_stop(manager);
tsk_semaphore_destroy(&manager->sem);
tsk_condwait_destroy(&manager->condwait);
tsk_mutex_destroy(&manager->mutex);
TSK_OBJECT_SAFE_FREE(manager->timers);
}
return self;
}
static const tsk_object_def_t tsk_timer_manager_def_s =
{
sizeof(tsk_timer_manager_t),
tsk_timer_manager_ctor,
tsk_timer_manager_dtor,
tsk_null,
};
const tsk_object_def_t * tsk_timer_manager_def_t = &tsk_timer_manager_def_s;
//=================================================================================================
// Timer object definition
//
static tsk_object_t* tsk_timer_ctor(tsk_object_t * self, va_list * app)
{
static volatile tsk_timer_id_t __tsk_unique_timer_id = 0;
tsk_timer_t *timer = (tsk_timer_t*)self;
if(timer){
tsk_atomic_inc(&__tsk_unique_timer_id);
timer->id = __tsk_unique_timer_id;
timer->timeout = va_arg(*app, uint64_t);
timer->callback = va_arg(*app, tsk_timer_callback_f);
timer->arg = va_arg(*app, const void *);
timer->timeout += tsk_time_now();
}
return self;
}
static tsk_object_t* tsk_timer_dtor(tsk_object_t * self)
{
tsk_timer_t *timer = (tsk_timer_t*)self;
if(timer){
}
return self;
}
static int tsk_timer_cmp(const tsk_object_t *obj1, const tsk_object_t *obj2)
{
const tsk_timer_t *t1 = (const tsk_timer_t *)obj1;
const tsk_timer_t *t2 = (const tsk_timer_t *)obj2;
if(t1 && t2){
return (int)(t1->timeout - t2->timeout);
}
else if(!t1 && !t2) return 0;
else return -1;
}
static const tsk_object_def_t tsk_timer_def_s =
{
sizeof(tsk_timer_t),
tsk_timer_ctor,
tsk_timer_dtor,
tsk_timer_cmp,
};
const tsk_object_def_t * tsk_timer_def_t = &tsk_timer_def_s;