condition.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <errno.h>
#include <time.h>
#include <stdlib.h>
#include <signal.h>
#include <iostream>

#include <archon/util/condition.H>
#include <archon/util/thread.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    Condition::Condition(Mutex &m): mutex(&m)
    {
      const int e = pthread_cond_init(&cond, 0);
      if(e != 0)
        ARCHON_THROW1(ResourceException,
                      "Could not initialize condition");
    }

    Condition::~Condition()
    {{ // The extra scope is needed to work around gcc3.2 bug #8287
      const int e = pthread_cond_destroy(&cond);
      if(e != 0)
      {
        if(e == EBUSY)
          ARCHON_THROW1(StateException,
                        "Attempt to destroy condition on which "
                        "threads are waiting");
        ARCHON_THROW1(InternalException,
                      "Attempt to destroy condition failed");   
      }
    }}

    void Condition::wait() throw(UnexpectedException)
    {
      Ref<Thread> self = Thread::self();
      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = this;
      }

      int error = 0;
      if(!self->terminateRequest)
        error = pthread_cond_wait(&cond, &mutex->mutex);

      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = 0;
      }

      if(error) ARCHON_THROW1(InternalException,
                              "pthread_cond_wait failed");
      if(self->terminateRequest) ARCHON_THROW(ThreadTerminatedException);
    }

    bool Condition::timedWait(Time timeout)
      throw(UnexpectedException)
    {
      Ref<Thread> self = Thread::self();
      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = this;
      }

      int error = 0;
      if(!self->terminateRequest)
        error = pthread_cond_timedwait(&cond, &mutex->mutex, &timeout.ts);

      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = 0;
      }

      bool timedout = false;
      if(error)
      {
        if(error == ETIMEDOUT) timedout = true;
        else if(error != EINTR)
          ARCHON_THROW1(InternalException,
                        "pthread_cond_timedwait failed");
      }
      if(self->terminateRequest) ARCHON_THROW(ThreadTerminatedException);
      return timedout;
    }


    namespace
    {
      const int signo = SIGUSR1;
      bool setupSignalDone = false;
      void sigDummy(int) {}
      void setupSignal()
      {
        struct sigaction sa, saOriginal;
        sigaction(signo, 0, &sa);
        saOriginal = sa;
        sa.sa_handler = &sigDummy;
        sigemptyset(&sa.sa_mask);
        sa.sa_flags &= ~(SA_RESTART|SA_RESETHAND);
        sa.sa_flags |= SA_NODEFER;
        sigaction(signo, &sa, 0);
      }
    }


    int Condition::select(int n, fd_set *readfds, fd_set *writefds,
                           fd_set *exceptfds, Time timeout)
      throw(UnexpectedException)
    {
      Time now = Time::now();
      if(timeout < now) timeout = Time();
      else timeout -= now;

      Ref<Thread> self = Thread::self();
      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = this;
      }

      int m = 0;
      int e;
      if(!self->terminateRequest)
      {
        // Block USR1 signal
        sigset_t oldSigset;
        sigset_t blockSigset;
        sigemptyset(&blockSigset);
        sigaddset(&blockSigset, signo);
        if(pthread_sigmask(SIG_BLOCK, &blockSigset, &oldSigset)!=0)
          ARCHON_THROW1(InternalException,
                        "pthread_sigmask failed");

        if(!setupSignalDone)
        {
          setupSignalDone = true;
          setupSignal();
        }

        list<pthread_t>::iterator sigThread;
        {
          Mutex::Lock l(sigThreadsMutex);
          sigThreads.push_back(pthread_self());
          sigThread = --sigThreads.end();
        }

        mutex->unlock();

        sigset_t unblockSigset = oldSigset;
        sigdelset(&blockSigset, signo);
        m = pselect(n, readfds, writefds, exceptfds,
                    &timeout.ts, &unblockSigset);
        e = errno;

        mutex->lock();

        {
          Mutex::Lock l(sigThreadsMutex);
          sigThreads.erase(sigThread);
        }

        // Restore signal mask
        if(pthread_sigmask(SIG_SETMASK, &oldSigset, 0)!=0)
          ARCHON_THROW1(InternalException,
                        "pthread_sigmask failed");
      }

      {
        Mutex::Lock l(self->waitConditionMutex);
        self->waitCondition = 0;
      }

      if(m < 0 && e != EINTR)
        ARCHON_THROW1(InternalException, "pselect failed: " +
                      string(strerror(e)));
      if(self->terminateRequest)
        ARCHON_THROW(ThreadTerminatedException);
      return m;
    }

    void Condition::notifySigThreads()
    {
      list<pthread_t>::iterator i = sigThreads.begin();
      while(i != sigThreads.end())
      {
        if(pthread_kill(*i, signo)!=0)
          ARCHON_THROW1(InternalException, "pthread_kill failed");
        ++i;
      }
    }
  }
}

---