Tanl Linguistic Pipeline

search/ixe/Common/Thread.cpp

/*
**      IXE
**      Common/Thread.cpp
** ----------------------------------------------------------------------
**      Copyright (c) 2002  Giuseppe Attardi (attardi@di.unipi.it).
** ----------------------------------------------------------------------
**
**  This file is part of IXE.
**
**  IXE is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  IXE 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 General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

// Library
#include "Common/Lock.h"
#include "include/error.h"

// standard
#include <iostream>

// local
#include "Common/Thread.h"
#include "Common/ThreadGroup.h"

#ifdef _WIN32
# include <process.h>
#else
# include <unistd.h>
#endif

using namespace std;

namespace IXE {

Thread::Thread(char const* name) :
  runnable(this),
  name(name),
  state(Created),
  group(ThreadGroup::Root())
{
  if (group) 
    group->add(this);
}

Thread::Thread(Runnable* target, char const* name) :
  runnable(target),
  name(name),
  state(Created),
  group(ThreadGroup::Root())
{
  if (!target)
    runnable = this;
  group->add(this);
}


Thread::Thread(ThreadGroup* group, Runnable* target, char const* name) :
  runnable(target),
  name(name),
  state(Created),
  group(group)
{
  if (!target)
    runnable = this;
  if (group) 
    group->add(this);
}

bool
Thread::inCurrentThread()
{
  return thread == GetCurrentThread();
}

Thread::~Thread() 
{
# ifndef _WIN32
  // needed to release the thread resources on Linux 2.4.
  // see http://www.parkes.atnf.csiro.au/computing_notes/linux_threads.html
  pthread_detach(thread);
# endif
  if (state == Terminated)
    return;
  if (group) {
    Locking(group->destroying,
    {
      if (group->destroying) {
        LeaveCriticalSection(&group->destroying._lock);
        //
        // The thread group to which we belong has had its destructor
        // called and is in the process of destroying itself and us.
        // Therefore, simply cancel our thread.
        //
        if (state != Terminated) {
          state = Terminated;
          TerminateThread(thread, 0);
        }
        return;
      }
    });
  }
  //
  // Delete the pointer to us in our thread group.
  //
  if (group)
    group->remove(this);

  LockUp our(_lock);
  if (state == Created)
    return;
  if (state != Terminated) {
    if (inCurrentThread())
      // we are committing suicide.
      ExitThread(0);
    else
      TerminateThread(thread, 0);
  }
}

int Thread::ActiveCount()
{
  return (group) ? group->ActiveCount() : 1;
}

void Thread::Join(int millis, int nanos)
  // throw(InvalidArgumentError, Exception)
{
  LockUp our(_lock);
  if (millis != -1 && millis < 0)
    throw InvalidArgumentError("timeout value is negative");
  if (nanos < 0 || nanos > 999999)
    throw InvalidArgumentError("nanosecond timeout value out of range");
  if (inCurrentThread())
    throw InvalidThreadStateError(string("self wait"));
  if (state != Running && state != Created)
    return;
  
# ifdef _WIN32
  if (millis == -1)
    millis = INFINITE;
  DWORD ret;
  ConditionWaitInterval(termination, &_lock, millis, nanos, ret);
  if (ret == 0xFFFFFFFF)
    throw SystemError("WaitForSingleObjectEx() failed");
# else // !_WIN32
  if (millis == -1) {
    ConditionWait(termination, &_lock);
  } else {
    int ret;
    ConditionWaitInterval(termination, &_lock, millis, nanos, ret);
    if (ret == ETIMEDOUT) {
      SYS_CALL(::pthread_join, (thread, 0));
      state = Detached;
    }
  }
# endif // _WIN32
}

// virtual
void 
Thread::Run() 
{
  cerr << "*** Thread::Run() called!. Should be overwritten!" << endl;
}

// static
TRESULT
Thread::Main(void* arg)
{
  Thread& th = *(Thread*)arg;
# ifndef _WIN32
  //
  // Add our clean-up function to this thread.  This will ensure
  // that we get removed from our thread pool's set of threads even if
  // the derived class author calls pthread_exit() directly.
  //

  // Attardi. Don't use it: if destructor was called thread pointer arg
  // is dangling.
  //pthread_cleanup_push(Destroy, arg);// no "::" (it's a macro)
# endif
  th.state = Running;
  th.runnable->Run(); 
  th.state = Terminated;
  try {
    if (th.group) {
      th.group->remove(&th); // to avoid cyclic references
      th.group = 0;
    }
  } catch (...) {
  }
# ifdef _MSC_VER
  _endthreadex(0);
# else
  th.termination.notify();
  //::pthread_cleanup_pop(0);
# endif
  delete &th;
  return 0;
}

void 
Thread::Start()
{
  LockUp our(_lock);
  if (state != Created)
    return;
  
# ifdef _WIN32
  unsigned int id;
#  ifdef _MSC_VER
  thread = (HANDLE)_beginthreadex(0, 0, Main, this, CREATE_SUSPENDED, &id);
#  else
  thread = CreateThread(NULL, 0, (DWORD (__stdcall*)(void *))Main, this, CREATE_SUSPENDED, &id);
#  endif
  if (thread == NULL)
    throw SystemError("CreateThread() failed");
  ResumeThread(thread);
# else // !_WIN32
  starting.In();
  int ret = ::pthread_create(&thread, NULL, Main, this);
  starting.Out();
  if (ret != 0) {
    throw SystemError(string("pthread_create() failed: ") + ret);
  }
# endif
}

// static
void 
Thread::Sleep(int millis, int nanos)
{
# ifdef _WIN32
  ::Sleep(millis);
# else
  struct timespec delay;
  long seconds = (millis / 1000);
  delay.tv_sec = seconds;
  long restmillis = millis % 1000;
  delay.tv_nsec = (restmillis) * 1000 + nanos;
  unsigned nsecs = delay.tv_sec * 1000000;
  nsecs += delay.tv_nsec / 1000;
  usleep(nsecs);
# endif
}

// static
void
Thread::Yield()
{
# ifdef _WIN32
  ::Sleep(0);
# else
  sched_yield();
# endif
}

// static
# ifdef _WIN32
HANDLE
# else
pthread_t
# endif
Thread::CurrentThreadId()
{
  return GetCurrentThread();
}

static
int threadPriorityTable[] =
{
# ifdef _WIN32
  THREAD_PRIORITY_HIGHEST,
  THREAD_PRIORITY_ABOVE_NORMAL,
  THREAD_PRIORITY_NORMAL,
  THREAD_PRIORITY_BELOW_NORMAL,
  THREAD_PRIORITY_LOWEST  
# else
  1,
  2,
  3,
  4,
  5
# endif
};

// virtual
int 
Thread::Priority()
{
# ifdef _WIN32
  DWORD erg = GetThreadPriority(thread);
  for (int i = 0; i < sizeof(threadPriorityTable) / sizeof(threadPriorityTable[0]); i++)
    if (threadPriorityTable[i] == erg)
      return i;
  return 2;
# else
  sched_param param;
  int policy;
  SYS_CALL(::pthread_getschedparam, (thread, &policy, &param));
  int prio = param.sched_priority;
  for (int i = 0; i < int(sizeof(threadPriorityTable) / sizeof(threadPriorityTable[0])); i++)
    if (threadPriorityTable[i] == prio)
      return i;
  return 2;
# endif
}

// virtual
void 
Thread::Priority(int newPriority)  
{
# ifdef _WIN32
  SetThreadPriority(thread, threadPriorityTable[newPriority]);
# else
  sched_param param;
  int policy = 0;
  SYS_CALL(::pthread_getschedparam, (thread, &policy, &param));
  param.sched_priority = threadPriorityTable[newPriority];
  SYS_CALL(::pthread_setschedparam, (thread, policy, &param));
# endif
}

bool
Thread::IsAlive()
{
  return state == Running;
}

} // namespace IXE

 

Copyright © 2005-2011 G. Attardi. Generated on 3 Mar 2011 by doxygen 1.6.1.