libjf API reference guide

jf_timer.c

Go to the documentation of this file.

/*
 * Copyright 2005 Tiian
 * {In real life Tiian is Christian Ferrari}
 * This file is part of "libjf" package.
 *
 * "libjf" is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * "libjf" 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 Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with ; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <jf/jf_config.h>



#include <jf/jf_errors.h>
#include <jf/jf_timer.h>
#include <jf/jf_trace.h>



/* set module trace flag */
#ifdef JF_TRACE_MODULE
# undef JF_TRACE_MODULE
#endif /* JF_TRACE_MODULE */
#define JF_TRACE_MODULE   JF_TRACE_MOD_LIB_TIMER



const char *jf_feature_timer = "feature/timer = " JF_FEATURE_TIMER_ACTIVE;



int jf_timer_reset(jf_timer_t *t)
{
        enum Exception { SYSCONF_ERROR
                         , NONE
                         , UNSUPPORTED_FUNCTION} excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_timer_reset\n"));
        TRY {
                t->started = FALSE;
#ifdef JF_TIMER_AVAILABLE
                if (-1 == (t->ticks_per_sec = sysconf(_SC_CLK_TCK)))
                        THROW(SYSCONF_ERROR);
                t->base_usr_time = t->base_sys_time = t->usr_time =
                        t->sys_time = 0;

                t->tz.tz_minuteswest = t->tz.tz_dsttime = 0;
                t->base_ela_time.tv_sec = t->ela_time.tv_sec = 0;
                t->base_ela_time.tv_usec = t->ela_time.tv_usec = 0;
                
                THROW(NONE);
#else
                THROW(UNSUPPORTED_FUNCTION);
#endif /* JF_TIMER_AVAILABLE */
        } CATCH {
                switch (excp) {
                    case SYSCONF_ERROR:
                        ret_cod = JF_RC_SYSCONF_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    case UNSUPPORTED_FUNCTION:
                        ret_cod = JF_RC_UNSUPPORTED_FUNCTION;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_timer_reset/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int jf_timer_start(jf_timer_t *t)
{
        enum Exception { INVALID_STATUS
                         , TIMES_ERROR
                         , GETTIMEOFDAY_ERROR
                         , NONE
                         , UNSUPPORTED_FUNCTION } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_timer_start\n"));
        TRY {
#ifdef JF_TIMER_AVAILABLE           
                struct tms tmp_tms;
                clock_t result;

                if (t->started)
                        THROW(INVALID_STATUS);
                
                if ((clock_t)-1 == (result = times(&tmp_tms)))
                        THROW(TIMES_ERROR);
                t->base_usr_time = tmp_tms.tms_utime;
                t->base_sys_time = tmp_tms.tms_stime;

                if (-1 == gettimeofday(&(t->base_ela_time), &(t->tz)))
                        THROW(GETTIMEOFDAY_ERROR);
                
                t->started = TRUE;
                
                THROW(NONE);
#else
                THROW(UNSUPPORTED_FUNCTION);
#endif /* JF_TIMER_AVAILABLE */
        } CATCH {
                switch (excp) {
                    case INVALID_STATUS:
                        ret_cod = JF_RC_INVALID_STATUS;
                        break;
                    case TIMES_ERROR:
                        ret_cod = JF_RC_TIMES_ERROR;
                        break;
                    case GETTIMEOFDAY_ERROR:
                        ret_cod = JF_RC_GETTIMEOFDAY_ERROR;
                        break;
                    case UNSUPPORTED_FUNCTION:
                        ret_cod = JF_RC_UNSUPPORTED_FUNCTION;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_timer_start/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}



int jf_timer_stop(jf_timer_t *t)
{
        enum Exception { INVALID_STATUS
                         , TIMES_ERROR
                         , GETTIMEOFDAY_ERROR
                         , NONE
                         , UNSUPPORTED_FUNCTION } excp;
        int ret_cod = JF_RC_INTERNAL_ERROR;

        JF_TRACE(("jf_timer_stop\n"));
        TRY {
#ifdef JF_TIMER_AVAILABLE
                struct tms tmp_tms;
                struct timeval tmp_timeval;
                clock_t result = times(&tmp_tms);

                if (!t->started)
                        THROW(INVALID_STATUS);
                
                if ((clock_t)-1 == result)
                        THROW(TIMES_ERROR);
                t->usr_time += tmp_tms.tms_utime - t->base_usr_time;
                t->sys_time += tmp_tms.tms_stime - t->base_sys_time;

                if (-1 == gettimeofday(&tmp_timeval, &(t->tz)))
                        THROW(GETTIMEOFDAY_ERROR);

                t->ela_time.tv_sec +=
                        tmp_timeval.tv_sec - t->base_ela_time.tv_sec;
                t->ela_time.tv_usec +=
                        tmp_timeval.tv_usec - t->base_ela_time.tv_usec;
                
                t->started = FALSE;
                
                THROW(NONE);
#else
                THROW(UNSUPPORTED_FUNCTION);
#endif /* JF_TIMER_AVAILABLE */
        } CATCH {
                switch (excp) {
                    case INVALID_STATUS:
                        ret_cod = JF_RC_INVALID_STATUS;
                        break;
                    case TIMES_ERROR:
                        ret_cod = JF_RC_TIMES_ERROR;
                        break;
                    case GETTIMEOFDAY_ERROR:
                        ret_cod = JF_RC_GETTIMEOFDAY_ERROR;
                        break;
                    case NONE:
                        ret_cod = JF_RC_OK;
                        break;
                    case UNSUPPORTED_FUNCTION:
                        ret_cod = JF_RC_UNSUPPORTED_FUNCTION;
                        break;
                    default:
                        ret_cod = JF_RC_INTERNAL_ERROR;
                } /* switch (excp) */
        } /* TRY-CATCH */
        JF_TRACE(("jf_timer_stop/excp=%d/"
                  "ret_cod=%d/errno=%d\n", excp, ret_cod, errno));
        return ret_cod;
}

---

Copyright 2005 © Tiian