---

timer.cc

Go to the documentation of this file.

/*
  timer.cc -- interval timer code.  A TIMER object lets you wait on
  the expiration of a cyclic period, to the resolution of the system
  clock.

  Ideally, we'd like to use the POSIX struct timespec, in timers.h,
  for second-nanosecond resolution in real time.  However, at the
  moment, most OSes do not have this interface since the POSIX realtime
  draft is still out.

  These functions use the BSD 'gettimeofday' interface for LynxOS and
  SunOS, and the tickLib and taskLib interface on VxWorks.
  */


#include "rcs_defs.hh"          // __MSDOS__
#include "dbg_mem.h"            // DEBUG_MALLOC,DEBUG_FREE

#ifdef VXWORKS

extern "C"
{
#include <vxWorks.h>

#ifndef NO_STDIO
#include <stdio.h>
#endif

#include <string.h>             // strtok(), strncmp()
#include <stdlib.h>             // atof()
#include <taskLib.h>            /* taskDelay() */
#include <tickLib.h>            /* tickGet() */
#include <sysLib.h>             /* sysClkRateGet() */
}

#endif                          /* VXWORKS */

#ifdef LYNX

extern "C"
{
#include <string.h>             // strtok(), strncmp()
#include <stdlib.h>             // atof()

#ifndef NO_STDIO
#include <stdio.h>              /* NULL */
#endif

#include <stdlib.h>             /* exit() */
#include <signal.h>             /* struct sigaction, sigaction(), SIGALRM,
                                   sigset_t */
#include <errno.h>              /* perror(), EINTR */
#include <unistd.h>             /* select() */
#include <time.h>               /* CLK_TCK, since no _SC_CLK_TCK, */
  /* setitimer() */
#include <sys/time.h>           /* struct timeval, gettimeofday(),
                                   struct itimerval,
                                   ITIMER_REAL */

}

#endif                          /* LYNX */

#if defined(SUN) || defined(LINUX)

extern "C"
{
#include <stdlib.h>             // atof()
#include <string.h>             // strtok(), strncmp()

#ifndef NO_STDIO
#include <stdio.h>              /* NULL */
#endif

#include <stdlib.h>             /* exit() */
#include <signal.h>             /* struct sigaction, sigaction(), SIGALRM,
                                   sigset_t */
#include <errno.h>              /* perror(), EINTR */
#include <unistd.h>             /* select(), sysconf(), _SC_CLK_TCK */
#include <sys/time.h>           /* struct timeval, gettimeofday(),
                                   struct itimerval, setitimer(),
                                   ITIMER_REAL */
#include <sys/types.h>
#include <sys/wait.h>           // waitpid()
}

#endif                          /* SUN */

#ifdef __MSDOS__
#include <stdlib.h>             // atof()
#include <string.h>             // strtok(), strncmp()
#include <time.h>               /* clock(), CLK_TCK */
#ifndef _WINDOWS
#include <dos.h>                /* delay() */
#endif
#endif

#include "inetfile.hh"          // inet_file_open(), inet_file_gets()

#include "timer.hh"

#define INT(x) ((int) (x))
#define FRAC(x) ((x) - INT(x))


#if (defined (SUN) || defined (LYNX)) && !defined(lynxosVME)  && !defined(sunos4CC)

/* set up SIGALRM to go off after time, either once or periodically */
int
itimer_set (double time, int periodic)
{
  struct itimerval val;
  long secs, usecs;

  /* set up the interval timer */
  secs = (long) time;           /* lose the fraction */
  usecs = (long) ((time - (double) secs) * 1000000.0);
  val.it_value.tv_sec = secs;
  val.it_value.tv_usec = usecs;
  if (periodic == 0)
    {
      val.it_interval.tv_sec = val.it_interval.tv_usec = 0;
    }
  else
    {
      val.it_interval.tv_sec = val.it_value.tv_sec;
      val.it_interval.tv_usec = val.it_value.tv_usec;
    }
  return setitimer (ITIMER_REAL, &val, 0);
}

/* do-nothing default function for itimer_attach() */
static void
noaction (...)
{
  return;
}

/* attach a function to the SIGALRM handler */
void
itimer_attach (RCS_SIGFUNC function)
{
  struct sigaction act;

  /* set up action to occur upon receipt of SIGALRM-- call function */
#ifdef sparcworks_sun4
  act.sa_handler =
    (void (*)(int,...)) ((function == NULL) ? noaction : function);
#else
#if defined(sparcworks_sun5) || defined(sunos5CC)       /* CenterLine is picky, picky, picky */
  act.sa_handler = (void (*)(int)) ((function == NULL) ? noaction : function);
#else
  act.sa_handler = ((function == NULL) ? noaction : function);
#endif
#endif
  sigfillset (&act.sa_mask);    /* mask all signals while in SIGALRM */
  act.sa_flags = 0;             /* no special flags */
  sigaction (SIGALRM, &act, NULL);
}

/* block on arrival of SIGALRM */
void
itimer_wait ()
{
  sigset_t mask;

  /* set up to block on SIGALRM */
  sigfillset (&mask);           /* block all signals */
  sigdelset (&mask, SIGALRM);   /* accept SIGALRM */
  sigsuspend (&mask);           /* block until SIGALRM is received */
}

#endif /* SUN or LYNX */


/* RCS_TIMER class */
RCS_TIMER::RCS_TIMER (char *process_name, char *config_file)
{
#if 0
  read_config_file (process_name, config_file);
#endif
}

RCS_TIMER::RCS_TIMER (double _timeout, char *process_name, char *config_file)
{
#if 0
  read_config_file (process_name, config_file);
#endif
  set_timeout (_timeout);
}

void
RCS_TIMER::set_timeout (double _timeout)
{
  timeout = _timeout;
  if (timeout < clk_tck ())
    {
      counts_per_real_sleep = (int) (clk_tck () / _timeout) + 1;
    }
  else
    {
      counts_per_real_sleep = 0;
    }
}

#if 0
void
RCS_TIMER::read_config_file (char *process_name, char *config_file)
{
  zero_timer ();
  if (NULL == process_name || NULL == config_file)
    {
      return;
    }
  INET_FILE *ifp = inet_file_open (config_file, "r");
  if (NULL == ifp)
    {
      return;
    }
  int process_name_length = strlen (process_name);
  char line[256];
  char *token;
  while (!inet_file_eof (ifp))
    {
      inet_file_gets (line, 256, ifp);
      token = strtok (line, " \r\n:\t\b,;");
      if (line[0] == '#')
        {
          continue;
        }
      if (token == NULL)
        {
          continue;
        }
      if (strncmp (token, process_name, process_name_length))
        {
          continue;
        }
      token = strtok (NULL, " \r\n:\t\b,;");
      if (NULL == token)
        {
          break;
        }
      timeout = atof (token);
      token = strtok (NULL, " \r\n:\t\b,;");
      if (NULL == token)
        {
          break;
        }
#if 0
      sem_key = strtol (token, NULL, 0);
      token = strtok (NULL, " \r\n:\t\b,;");
      if (NULL == token)
        {
          break;
        }
      num_sems = strtol (token, NULL, 0);
      token = strtok (NULL, " \r\n:\t\b,;");
      if (NULL == token)
        {
          break;
        }
#endif
      id = strtol (token, NULL, 0);
      token = strtok (NULL, " \r\n:\t\b,;");
      if (NULL == token)
        {
          break;
        }
#if 0
      create_sems = strtol (token, NULL, 0);
#endif
    }
  inet_file_close (ifp);
  init (timeout, id);
}
#endif



void
RCS_TIMER::zero_timer ()
{
  num_sems = 0;
#if USE_SEMS_FOR_TIMER
  sems = NULL;
#endif
  id = 0;
  function = NULL;
  idle = 0.0;                   /* set accumulated idle time to 0.0 */
  counts = 0;                   /* set accumulated waits to 0 */
  start_time = etime ();        /* set creation time to now */
  time_since_real_sleep = start_time;
  counts_per_real_sleep = 0;
  counts_since_real_sleep = 0;
  clk_tck_val = clk_tck ();
  timeout = clk_tck_val;
}



void
RCS_TIMER::init (double _timeout, int _id)
{
  zero_timer ();
  id = _id;
#if 0
  num_sems = _num_sems;
  int sem_key = _sem_key;
  int create_sems = _create_sems;
  if (num_sems > 0 && id >= 0 && id < num_sems)
    {
      sems =
        (RCS_SEMAPHORE **) DEBUG_MALLOC (sizeof (RCS_SEMAPHORE *) * num_sems);
      for (int i = 0; i < num_sems; i++)
        {
          sems[i] = new RCS_SEMAPHORE (sem_key + i, create_sems, -1);
        }
      sems[id]->post ();
      poller_pid = fork ();
      if (poller_pid == 0)
        {
          timer_poll (_timeout, sems[id]);
        }
    }
  else
    {
      num_sems = 0;
    }
#endif
  set_timeout (_timeout);

}



RCS_TIMER::RCS_TIMER (double _timeout, RCS_TIMERFUNC _function, void *_arg)
{
  zero_timer ();
  counts_per_real_sleep = 0;
  counts_since_real_sleep = 0;

  if (_timeout < clk_tck_val)
    {
      counts_per_real_sleep = (int) (clk_tck_val / _timeout);
      /* bump interval up to minimum system clock tick */
      timeout = clk_tck_val;
    }
  else
    {
      timeout = _timeout;
    }
  function = _function;
  arg = _arg;
  last_time = etime ();         /* initialize start time and last time called
                                   to current time since epoch */
  idle = 0.0;                   /* set accumulated idle time to 0.0 */
  counts = 0;                   /* set accumulated waits to 0 */
  start_time = etime ();        /* set creation time to now */
  time_since_real_sleep = start_time;
}

/* Restart the timing interval. */
void
RCS_TIMER::sync ()
{
  last_time = etime ();         /* initialize start time and last time called
                                   to current time since epoch */
}

int
RCS_TIMER::wait ()
{
  double interval;              /* interval between this and last wakeup */
  double numcycles;             /* interval, in units of timeout */
  int missed = 0;               /* cycles missed */
  double remaining = 0.0;       /* time remaining until timeout */
  double time_in = 0.0;         /* time wait() was entered */
  double time_done = 0.0;       /* time user function finished */
  /* first call the user timing function, if any */
  if (function != NULL)
    {
      /* set time in */
      time_in = etime ();

      if ((*function) (arg) == -1)
        {
          return -1;            /* fatal error in timing function */
        }
      time_done = etime ();
    }
  else
    {
      /* set time in, time done not used */
      time_in = etime ();
    }

  /* calculate the interval-- for user timing functions, this is how
     long between this wakeup and the last wakeup.  For internal timers,
     this is how long we need to sleep to make it to the next interval
     on time. */
  interval = time_in - last_time;
  numcycles = interval / timeout;

  /* synchronize and set last_time correctly; update idle time */
  counts++;
  if (function != NULL)
    {
      missed = INT (numcycles - (clk_tck_val / timeout));
      idle += interval;
      last_time = time_done;
    }
  else
    {
      missed = INT (numcycles);
      remaining = timeout * (1.0 - FRAC (numcycles));
      idle += interval;
#if 0
      if (counts_per_real_sleep > 0)
        {
          if (counts_since_real_sleep < counts_per_real_sleep)
            {
              counts_since_real_sleep++;
              if (sems != NULL && num_sems > 0)
                {
                  for (i = id + 1; i < num_sems && !sem_posted; i++)
                    {
                      if (i != id && NULL != sems[i])
                        {
                          if (sems[i]->post () < 0)
                            {
                              delete sems[i];
                              sems[i] = NULL;
                              if (i == num_sems - 1)
                                {
                                  num_sems--;
                                }
                            }
                          else
                            {
                              sem_posted = 1;
                            }
                        }
                    }
                  for (i = 0; i < id && !sem_posted; i++)
                    {
                      if (i != id && NULL != sems[i])
                        {
                          if (sems[i]->post () < 0)
                            {
                              delete sems[i];
                              sems[i] = NULL;
                              if (i == num_sems - 1)
                                {
                                  num_sems--;
                                }
                            }
                          else
                            {
                              sem_posted = 1;
                            }
                        }
                    }
                  if (NULL != sems[id] && sem_posted)
                    {
                      if (sems[id]->wait () < 0)
                        {
                          delete sems[id];
                          sems[id] = NULL;
                          return 0;
                        }
                      while (etime () - time_in < remaining)
                        {
                          if (sems[id]->wait () < 0)
                            {
                              delete sems[id];
                              sems[id] = NULL;
                              break;
                            }
                        }
                      for (i = 0; i < num_sems; i++)
                        {
                          if (i != id && NULL != sems[i])
                            {
                              sems[i]->clear ();
                            }
                        }
                    }
                  return 0;
                }
            }
          counts_since_real_sleep = 0;
          time_since_real_sleep = etime ();
          esleep (clk_tck_val);
          last_time = etime ();
          return missed;
        }
#endif
    }
  esleep (remaining);
  last_time = etime ();
  return missed;
}

double
RCS_TIMER::load ()
{
  if (counts * timeout != 0.0)
    return idle / (counts * timeout);
  return -1.0;
}

RCS_TIMER::~RCS_TIMER ()
{
#if 0
  if (poller_pid > 0)
    {
      kill (poller_pid, SIGINT);
#ifdef SUN
      waitpid (poller_pid, NULL, 0);
#endif
      poller_pid = 0;
    }
  if (NULL != sems)
    {
      for (int i = 0; i < num_sems; i++)
        {
          if (sems[i] != NULL)
            {
              delete sems[i];
            }
          sems[i] = NULL;
        }
      DEBUG_FREE (sems);
    }
#endif
}

---