Project Finished

asyncproject/timerlib.c

@@ -0,0 +1,301 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <assert.h>
+#include <errno.h>
+#include "timerlib.h"
+
+unsigned long
+timespec_to_millisec(
+	struct timespec* time) {
+
+	unsigned long milli_sec = 0;
+
+	milli_sec = time->tv_sec * 1000;
+	milli_sec += time->tv_nsec / 1000000;
+	return milli_sec;
+}
+
+void
+timer_fill_itimerspec(struct timespec* ts,
+	unsigned long msec) {
+
+	memset(ts, 0, sizeof(struct timespec));
+
+	if (!msec) return;
+
+	unsigned long sec = msec / 1000;
+	ts->tv_sec = sec;
+
+	unsigned long remaining_msec = msec % 1000;
+
+	ts->tv_nsec = remaining_msec * (1000000);
+}
+
+static void
+timer_callback_wrapper(union sigval arg) {
+
+	Timer_t* timer = (Timer_t*)(arg.sival_ptr);
+
+	timer->invocation_counter++;
+
+	if (timer->thresdhold &&
+		(timer->invocation_counter > timer->thresdhold)) {
+		cancel_timer(timer);
+		return;
+	}
+
+	(timer->cb)(timer, timer->user_arg);
+
+	if (timer->exponential_backoff) {
+
+		assert(timer->exp_back_off_time);
+		reschedule_timer(timer,
+			timer->exp_back_off_time *= 2, 0);
+	}
+	else if (timer->timer_state == TIMER_RESUMED) {
+
+		reschedule_timer(timer,
+			timer->exp_timer, timer->sec_exp_timer);
+	}
+}
+
+
+/*  Returns NULL in timer creation fails, else
+ *  return a pointer to Timer object*/
+Timer_t*
+setup_timer(
+	void (*timer_cb)(Timer_t*, void*), /*  Timer Callback with user data*/
+	unsigned long exp_timer,         	/*  First expiration time interval in msec */
+	unsigned long sec_exp_timer,        /*  Subsequent expiration time interval in msec */
+	uint32_t threshold,					/*  Max no of expirations, 0 for infinite*/
+	void* user_arg,                  	/*  Arg to timer callback */
+	bool exponential_backoff) {			/*  Is Timer Exp backoff*/
+
+	Timer_t* timer = calloc(1, sizeof(Timer_t));
+	timer->posix_timer = calloc(1, sizeof(timer_t));
+
+	timer->user_arg = user_arg;
+	timer->exp_timer = exp_timer;
+	timer->sec_exp_timer = sec_exp_timer;
+	timer->cb = timer_cb;
+	timer->thresdhold = threshold;
+	timer_set_state(timer, TIMER_INIT);
+	timer->exponential_backoff = exponential_backoff;
+
+	/* Sanity checks */
+	assert(timer->cb);	/* Mandatory */
+
+
+	struct sigevent evp;
+	memset(&evp, 0, sizeof(struct sigevent));
+
+	evp.sigev_value.sival_ptr = (void*)(timer);
+	evp.sigev_notify = SIGEV_THREAD;
+	evp.sigev_notify_function = timer_callback_wrapper;
+
+	int rc = timer_create(CLOCK_REALTIME,
+		&evp, timer->posix_timer);
+
+	assert(rc >= 0);
+
+	timer_fill_itimerspec(&timer->ts.it_value, timer->exp_timer);
+
+	if (!timer->exponential_backoff) {
+		timer_fill_itimerspec(&timer->ts.it_interval, timer->sec_exp_timer);
+		timer->exp_back_off_time = 0;
+	}
+	else {
+		timer->exp_back_off_time = timespec_to_millisec(&timer->ts.it_value);
+		timer_fill_itimerspec(&timer->ts.it_interval, 0);
+	}
+	return timer;
+}
+
+void
+resurrect_timer(Timer_t* timer) {
+
+	int rc;
+	rc = timer_settime(*(timer->posix_timer), 0, &timer->ts, NULL);
+	assert(rc >= 0);
+}
+
+void
+start_timer(Timer_t* timer) {
+
+	resurrect_timer(timer);
+	timer_set_state(timer, TIMER_RUNNING);
+}
+
+void
+delete_timer(Timer_t* timer) {
+
+	int rc;
+	rc = timer_delete(*(timer->posix_timer));
+	assert(rc >= 0);
+	timer->user_arg = NULL; /* User arg need to be freed by Appln */
+	timer_set_state(timer, TIMER_DELETED);
+	free(timer->posix_timer);
+	free(timer);
+}
+
+void
+cancel_timer(Timer_t* timer) {
+
+	TIMER_STATE_T timer_curr_state;
+
+	timer_curr_state = timer_get_current_state(timer);
+
+	if (timer_curr_state == TIMER_INIT ||
+		timer_curr_state == TIMER_DELETED) {
+
+		return; /*  No-Operation */
+	}
+
+	/* Only Paused or running timer can be cancelled */
+	timer_fill_itimerspec(&timer->ts.it_value, 0);
+	timer_fill_itimerspec(&timer->ts.it_interval, 0);
+	timer->time_remaining = 0;
+	timer->invocation_counter = 0;
+	resurrect_timer(timer);
+	timer_set_state(timer, TIMER_CANCELLED);
+}
+
+
+void
+pause_timer(Timer_t* timer) {
+
+	if (timer_get_current_state(timer) == TIMER_PAUSED)
+		return;
+
+	timer->time_remaining =
+		timer_get_time_remaining_in_mill_sec(timer);
+
+	timer_fill_itimerspec(&timer->ts.it_value, 0);
+	timer_fill_itimerspec(&timer->ts.it_interval, 0);
+
+	resurrect_timer(timer);
+
+	timer_set_state(timer, TIMER_PAUSED);
+}
+
+
+void
+resume_timer(Timer_t* timer) {
+
+	assert(timer_get_current_state(timer) == TIMER_PAUSED);
+
+	timer_fill_itimerspec(&timer->ts.it_value, timer->time_remaining);
+	timer_fill_itimerspec(&timer->ts.it_interval, timer->sec_exp_timer);
+	timer->time_remaining = 0;
+
+	resurrect_timer(timer);
+	timer_set_state(timer, TIMER_RESUMED);
+}
+
+unsigned long
+timer_get_time_remaining_in_mill_sec(Timer_t* timer) {
+
+	struct itimerspec remaining_time;
+
+	switch (timer->timer_state) {
+
+	case TIMER_INIT:
+		break;
+	case TIMER_DELETED:
+		return ~0;
+	case TIMER_PAUSED:
+		break;
+	case TIMER_CANCELLED:
+		return ~0;
+	case TIMER_RUNNING:
+		break;
+	default:;
+	}
+
+	memset(&remaining_time, 0, sizeof(struct itimerspec));
+
+	timer_gettime(*timer->posix_timer, &remaining_time);
+
+	return timespec_to_millisec(&remaining_time.it_value);
+}
+
+void
+restart_timer(Timer_t* timer) {
+
+	assert(timer->timer_state != TIMER_DELETED);
+
+	cancel_timer(timer);
+
+	timer_fill_itimerspec(&timer->ts.it_value, timer->exp_timer);
+
+	if (!timer->exponential_backoff)
+		timer_fill_itimerspec(&timer->ts.it_interval, timer->sec_exp_timer);
+	else
+		timer_fill_itimerspec(&timer->ts.it_interval, 0);
+
+	timer->invocation_counter = 0;
+	timer->time_remaining = 0;
+	timer->exp_back_off_time = timer->exp_timer;
+	resurrect_timer(timer);
+	timer_set_state(timer, TIMER_RUNNING);
+}
+
+
+void
+reschedule_timer(Timer_t* timer,
+	unsigned long exp_ti,
+	unsigned long sec_exp_ti) {
+
+	uint32_t invocation_counter;
+	TIMER_STATE_T timer_state;
+
+	timer_state = timer_get_current_state(timer);
+
+	if (timer_state == TIMER_DELETED) assert(0);
+
+	invocation_counter = timer->invocation_counter;
+
+	if (timer_state != TIMER_CANCELLED) {
+		cancel_timer(timer);
+	}
+
+	timer->invocation_counter = invocation_counter;
+
+	timer_fill_itimerspec(&timer->ts.it_value, exp_ti);
+
+	if (!timer->exponential_backoff) {
+		timer_fill_itimerspec(&timer->ts.it_interval, sec_exp_ti);
+	}
+	else {
+		timer_fill_itimerspec(&timer->ts.it_interval, 0);
+		timer->exp_back_off_time = exp_ti;
+	}
+
+	timer->time_remaining = 0;
+	resurrect_timer(timer);
+	timer_set_state(timer, TIMER_RUNNING);
+}
+
+void
+print_timer(Timer_t* timer) {
+
+	printf("Counter = %u, time remaining = %lu, state = %d\n",
+		timer->invocation_counter,
+		timer_get_time_remaining_in_mill_sec(timer),
+		timer_get_current_state(timer));
+}
+
+bool
+is_timer_running(Timer_t* timer) {
+
+	TIMER_STATE_T timer_state;
+
+	timer_state = timer_get_current_state(timer);
+
+	if (timer_state == TIMER_RUNNING ||
+		timer_state == TIMER_RESUMED) {
+		return true;
+	}
+	return false;
+}