marclock.cpp

Go to the documentation of this file.

#include "marclock.h"

#include <stdio.h>
#include <signal.h>
#include <sys/time.h>
#include <unistd.h>
#include <stdlib.h>

#define MAXCLQUEUE      100
#define HEART_GRAIN     (0.1)   /* timer grain */

int     heartbeat_grain_sec = 0;
int     heartbeat_grain_usec = 100000;
int     heartbeat_fast_sec = 0;
int     heartbeat_fast_usec = 20000;

struct clq_st {
  int           clq_used;       /* 0 if currently not used, else 1 */
  int           clq_ival;       /* interval timer value */
  struct clq_st *clq_prev;      /* pointer to prev quque entry */
  struct clq_st *clq_next;      /* pointer to next quque entry */
  void          (*clq_fcn)(int);/* fcn to execute on when ival = 0 */
  int           clq_arg;        /* argument to the above function */
};

typedef struct clq_st   clq;

clq     *clqhead;               /* points to first queue entry */
clq     clqueue[MAXCLQUEUE];    /* array containing the clock queue */
int     block_heartbeat;        /* 1 to temporarily block clock heartbeat */
int     clq_is_init = 0;        /* 1 if queues are initialized */

double  heartbeat_grain = HEART_GRAIN;

// void set_timer_params();
// void start_timer();
// void set_timer_grain();
// void enqueue_fcn(void (*fcn)(int), int arg, double dtval);
// void clock_heartbeat();
// void init_clock();

MarClock::MarClock(QObject *parent)
  : inherited(parent)
{
}

/******************************************************************
 * Function: mar_heartbeat
 ******************************************************************/
void
MarClock::mar_heartbeat(int)
{
  /*
   * Re-enable the timer, and return.
   */
  enqueue_fcn(mar_heartbeat,0,1.0);
}

/******************************************************************
 * Function: mar_clock
 ******************************************************************/
void
MarClock::mar_clock()
{
  int           i, killtimer = 0;

  enqueue_fcn(mar_heartbeat,0,1.0);
  //  enqueue_fcn((void (*)(int))get_status,0,1.0);

  init_clock();

  while(killtimer == 0) {
    pause();
  }
}


/******************************************************************
 * Function: set_timer_params
 ******************************************************************/
void
MarClock::set_timer_params(double val)
{
  double        x;
  int   i;

  x = val;
  i = (int) x;
  heartbeat_grain_sec = i;
  x = x - i;
  if(x < 0) x = 0;
  i = x * 1000000;
  heartbeat_grain_usec = i;

  x = val / 5;  /* for the fast timer on heartbeat block */
  i = (int) x;
  heartbeat_fast_sec = i;
  x = x - i;
  if(x < 0) x = 0;
  i = x * 1000000;
  heartbeat_fast_usec = i;

  return;
}

/******************************************************************
 * Function: start_timer
 ******************************************************************/
void
MarClock::start_timer(void (*fcn)(int), int speed)
{
  struct        itimerval       tv;

  tv.it_interval.tv_sec = 0;
  tv.it_interval.tv_usec = 0;
  if(speed == 0)
    {
      tv.it_value.tv_sec = heartbeat_fast_sec;
      tv.it_value.tv_usec = heartbeat_fast_usec;
    }
  else
    {
      tv.it_value.tv_sec = heartbeat_grain_sec;
      tv.it_value.tv_usec = heartbeat_grain_usec;
    }

  signal(SIGALRM,fcn);

  setitimer(ITIMER_REAL,&tv,NULL);
}

/******************************************************************
 * Function: set_timer_grain
 ******************************************************************/
void
MarClock::set_timer_grain(double val)
{
  heartbeat_grain = val;

  set_timer_params(val);
}


/******************************************************************
 * Function: enqueue_fcn  
 ******************************************************************/
void
MarClock::enqueue_fcn(void (*fcn)(int), int arg, double dtval)
{
  int   i,j;
  clq   *qp;

  block_heartbeat = 1;
  if(clq_is_init == 0)
    {
      clqhead = NULL;
      for(i = 0;i < MAXCLQUEUE; i++)
        clqueue[i].clq_used = 0;
      clq_is_init = 1;
    }
  for(i = 0;i < MAXCLQUEUE;i++)
    if(clqueue[i].clq_used == 0)
      {
        clqueue[i].clq_used = 1;
        j = .5 + dtval / heartbeat_grain;
        if(j == 0) j = 1;
        clqueue[i].clq_ival = j;
        clqueue[i].clq_fcn = fcn;
        clqueue[i].clq_arg = arg;
        clqueue[i].clq_next = NULL;
        if(clqhead == NULL)
          {
            clqhead = &clqueue[i];
            clqueue[i].clq_prev = NULL;
            block_heartbeat = 0;
            return;
          }
        for(qp = clqhead; ; qp = qp->clq_next)
          if(qp->clq_next == NULL)
            {
              qp->clq_next = &clqueue[i];
              clqueue[i].clq_prev = qp;
              block_heartbeat = 0;
              return;
            }
      }
  fprintf(stdout,"enqueue_fcn:  no more clock queue entries avail\n");
  ::exit(1);
}


/******************************************************************
 * Function: clock_heartbeat
 ******************************************************************/
void
MarClock::clock_heartbeat(int)
{
  clq                   *qp;

  if(block_heartbeat == 1)
    {
      /*
       *        If the heartbeat is blocked (e.g., by the enqueue_fcn
       *        routine), then we just re-enable the timer to be called
       *        again in 1/5th the normal clock grain.  Since functions
       *        which block heartbeat must be quick, this fast time
       *        will cause sucessful execution on the next timer callout.
       */

      start_timer(clock_heartbeat,0);

      return;
    }

  if(clqhead == NULL)
    {
      /*
       *        There are no functions queued for execution.  Depending
       *        on how the application which uses these routines is
       *        written, this condition may indicate an error.  In a
       *        completely clock callout driver application, this should
       *        happen ONLY before the first callout is queued, and never
       *        again.  Since there are other ways to use these routines,
       *        we don't flag an error here.
       */

      start_timer(clock_heartbeat,1);

      return;
    }

  /*
   *    Decrement the clq_ival variables in all active queue
   *    entries.  Do not decrement any entries whose clq_ival
   *    has already gone to zero.  These will executed on a
   *    first come, first served basis.
   */
  for(qp = clqhead; qp != NULL; qp = qp->clq_next)
    {
      if(qp->clq_ival > 0)
        qp->clq_ival--;
    }
        
  /*
   *    Queue the next heartbeat now.
   */
        
  start_timer(clock_heartbeat,1);

  /*
   *    Find the first entry in the queue whose clq_ival value
   *    is zero.  Unqueue it and execute it.
   */

  for(qp = clqhead; qp != NULL; qp = qp->clq_next)
    if(qp->clq_ival == 0)
      {
        if(qp->clq_prev == NULL)
          {
            clqhead = qp->clq_next;
            if(qp->clq_next != NULL)
              (qp->clq_next)->clq_prev = NULL;
          }
        else
          {
            (qp->clq_prev)->clq_next = qp->clq_next;
            if(qp->clq_next != NULL)
              (qp->clq_next)->clq_prev = qp->clq_prev;
          }

        qp->clq_used = 0;

        (void) (*qp->clq_fcn)(qp->clq_arg);

        return;
      }
  return;
}


/******************************************************************
 * Function: void init_clock
 ******************************************************************/
void
MarClock::init_clock()
{
  int                   i;

  if(clq_is_init == 0)
    {
      clqhead = NULL;
      for(i = 0;i < MAXCLQUEUE; i++)
        clqueue[i].clq_used = 0;
      clq_is_init = 1;
    }

  set_timer_params(heartbeat_grain);

  start_timer(clock_heartbeat,1);
}