Search  

---

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

Go to the documentation of this file.

#ifndef __J2K__Thread_CPP__
#define __J2K__Thread_CPP__

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

// Assign default values and set PID = -1
// to indicate that no thread was created yet.
inline Thread()
  : start_stack( DEFAULT_STACK ), 
    start_algo(  DEFAULT_ALGO  ), 
    start_prio(  DEFAULT_PRIO  ), 
    start_param( NULL ),
    pid( -1 )
    { }

// , MC_Serialization( THREAD_SERIAL )

// beginthread() can only call STATIC functions.
static void FAR Thread::Wrapper( void* ptrThis ) 
{
  Thread* me = (Thread*)ptrThis;
  me->run();  // Run the Thread implemented by it's children

  // run() should contain an Infinite Loop, i.e. for(;;) { ... }
  // Exit beautifully, just in case there is no infinite loop.

  _endthread();   
}

void Thread::start( size_t stack_size, int alg, int prio ) {
  if ( pid > 0 ) {
    _endthread();  // Kill current Thread.
  }

  // Call the static Wrapper() which will call the dynamic run()
  pid = _beginthread( &Wrapper, NULL, stack_size, this );
  qnx_scheduler( 0, pid, alg, prio, 0);

  start_param = getSchedulerParams();

  start_stack( stack_size );
  start_algo(  alg  );
  start_prio(  prio );
}

inline void Thread::stop() {
  _endthread();
  pid = -1;
}

inline int Thread::getPriority() {
  return getprio( pid );
}

inline void Thread::setPriority( int prio ) {
  setprio( pid, prio );
}

inline void Thread::resetPriority() {
  setprio( pid, start_prio );
}

inline int Thread::getScheduler() { 
  return sched_getscheduler( pid );
}

inline void Thread::setScheduler( int sched ) {
  struct sched_param* param;
  sched_getparam( pid, param );
  sched_setscheduler( pid, sched, param );
}

inline void Thread::resetScheduler() {
  setScheduler( start_algo );
}

inline struct sched_param*  Thread::getSchedulerParam() {
}

inline void Thread::setSchedulerParam( struct sched_param* param ) {
}

inline void Thread::resetSchedulerParam() {
}

inline Thread::~Thread() {
  stop();
}

inline pid_t Thread::getPID() {
  return pid;
}

inline int Thread::isStarted() {
  return ( pid > 0 );
}

// Kill the old version of Thread and Start it again.
// Return, if Thread was not started.
void Thread::refresh() 
{
  if (pid < 1) return;
  _endthread();
  start( start_stack, start_algo, start_prio );
}

#endif

---