Search  

---

C:/temp/src/j2k/QNX4/TimerThread.cpp

Go to the documentation of this file.

#ifndef __J2K__TimerThread_CPP__
#define __J2K__TimerThread_CPP__

/*
   Simple periodically executed thread.  
   Overrides MsgThread with its own message.

   You are able to add a response table to this thread, 
   but I really don't recommend it unless you're sure 
   it won't impact on the response time.

   Note that the timer is message number -1.  
   It invokes the virtual function tick()
*/

#include <j2k/Fred/QNX/TimerThread.hpp>

const int TimerThread::defaultMsg = -1;

TimerThread::TimerThread()
  : MsgThread(),
    Timer_ID( -1 ),
    Proxy_ID( -1 )
    { }

TimerThread::~TimerThread() {
  stop();
}

/*
 * Purpose:  Arm the timer thread.  It will fire at the next period.
 *
 * Input:    period  : time period of timer.  Timer will then fire
 *                     every period.  First fire is after one period.
 *
 *           algorithm, priority, stack_size for the Thread.
 *
 * Output:   PID of the thread.
 */

pid_t  TimerThread::start( timespec&  period,
                           int        algorithm,
                           int        priority,
                           size_t     stack_size  )
{

  if ( MsgThread::start( algorithm, priority, stack_size ) < 0 ) {
    return -1;
  }

  // Create a Proxy
  Proxy_ID = qnx_proxy_attach( Thread::pid,
                               (char*)&defaultMsg,
                               sizeof(&defaultMsg),
                               priority             );

  if ( Proxy_ID < 0 ) {
    stop();
    return -1;
  }

  // Create a timer
  struct sigevent evt;
  evt.sigev_signo = -Proxy_ID;
  Timer_ID = timer_create( CLOCK_REALTIME, &evt );

  if ( Timer_ID < 0 ) {
    stop();
    return -1;
  }

  // Set the Timer
  itimerspec timer;
  timer.it_value    = period;
  timer.it_interval = period;

  if ( timer_settime( timer_ID, 0, &timer, NULL ) < 0 ) {
    stop();
    return -1;
  }

  return Thread::pid;
}

/*
 * Purpose:  Stop the Thread and clean up.
 */
int TimerThread::stop()
{
  // Kill the running Timer
  if ( Timer_ID >= 0 ) {
    timer_delete( Timer_ID );
    timer_ID = -1;
  }

  // Kill Timer Proxy
  if ( Proxy_ID >= 0 ) {
    qnx_proxy_detach( Proxy_ID );
    Proxy_ID = -1;
  }

  // Let previous parent clean up
  return MsgThread::stop();
}


/*
 * Purpose:  Filters the timeout message (ID -1)
 *
 * Input:    msg     : Message recieved
 *           data    : Message data
 *           pid     : PID of sender
 *
 * Output:   Returns 1, if we are filtering the message 
 *           (i.e., pid = Proxy_ID and msg = -1)
 */

int TimerThread::message_filter( int msg, char* data, pid_t pid )
{
  if ( pid == Proxy_ID  &&  msg == defaultMsg ) {
    tick();
    return 1;
  }
  return 0;
}

int MsgSort( void* msg, void* ptrThis, pid_t rPid, void* p )
{
  if ( rPid == Proxy_ID && (*((int*)msg)) == MSG_TIMER_TICK ) {
    p = NULL;
    Tick();   // The message was valid call Tick()
    return MSG_TIMER_TICK;
  }
  return 0;
}

#endif

---