ThreadSupport.h

Go to the documentation of this file.

// -*- mode: C++; indent-tabs-mode: nil; c-basic-offset: 4; tab-width: 4; -*-
// vim: set shiftwidth=4 softtabstop=4 expandtab:
/*
 ********************************************************************
 ** NIDAS: NCAR In-situ Data Acquistion Software
 **
 ** 2006, Copyright University Corporation for Atmospheric Research
 **
 ** This program is free software; you can redistribute it and/or modify
 ** it under the terms of the GNU General Public License as published by
 ** the Free Software Foundation; either version 2 of the License, or
 ** (at your option) any later version.
 **
 ** This program 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.
 **
 ** The LICENSE.txt file accompanying this software contains
 ** a copy of the GNU General Public License. If it is not found,
 ** write to the Free Software Foundation, Inc.,
 ** 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 **
 ********************************************************************
*/
 
#ifndef NIDAS_UTIL_THREADSUPPORT_H
#define NIDAS_UTIL_THREADSUPPORT_H
 
#include <pthread.h>
#include <semaphore.h>
#include <string>
#include <iostream>
 
#include "Exception.h"
 
namespace nidas { namespace util {
 
class MutexAttributes
{
public:
 
    MutexAttributes();
 
    MutexAttributes(const MutexAttributes&);
 
    ~MutexAttributes();
 
    void setType(int val);
    int getType() const;
 
#ifdef PTHREAD_PRIO_INHERIT
    void setPriorityCeiling(int val) throw(Exception);
    int getPriorityCeiling() const;
#endif
 
#ifdef PTHREAD_PRIO_INHERIT
    void setProtocol(int val) throw(Exception);
    int getProtocol() const;
#endif
 
    void setPShared(int val);
    int getPShared() const;
 
 
    pthread_mutexattr_t* ptr()
    {
        return &_attrs;
    }
private:
    pthread_mutexattr_t _attrs;
};
 
class RWLockAttributes
{
public:
    RWLockAttributes();
 
    RWLockAttributes(const RWLockAttributes&);
 
    ~RWLockAttributes();
 
    void setPShared(int val);
    int getPShared() const;
 
 
    pthread_rwlockattr_t* ptr()
    {
        return &_attrs;
    }
private:
    pthread_rwlockattr_t _attrs;
};
 
class Mutex 
{
 
public:
    explicit Mutex(int type=PTHREAD_MUTEX_DEFAULT) throw();
 
    Mutex(const MutexAttributes& attr);
 
    Mutex(const Mutex& x) throw();
 
    ~Mutex();
 
    void lock()
    {
        int res;
        if((res = ::pthread_mutex_lock(&_p_mutex)))
            throw Exception("Mutex::lock",res);
    }
 
    void unlock()
    {
        int res;
        if ((res = ::pthread_mutex_unlock(&_p_mutex)))
            throw Exception("Mutex::unlock",res);
    }
 
    pthread_mutex_t* ptr();
 
private:
    Mutex& operator=(const Mutex&);
 
    pthread_mutex_t _p_mutex;
 
    MutexAttributes _attrs;
 
};
 
class Cond 
{
 
public:
 
    Cond() throw();
 
    Cond (const Cond &x) throw();
 
    ~Cond();
 
    void lock()
    {
        _mutex.lock();
    }
 
    void unlock()
    {
        _mutex.unlock();
    }
 
    void signal()
    {
        // only fails with EINVAL if _p_cond is not initialized.
        int res;
        if ((res = ::pthread_cond_signal (&_p_cond)))
            throw Exception("Cond::signal",res);
    }
 
    void broadcast()
    {
        int res;
        // only fails with EINVAL if _p_cond is not initialized.
        if ((res = ::pthread_cond_broadcast (&_p_cond)))
            throw Exception("Cond::broadcast",res);
    }
 
    void wait();
 
private:
    Cond &operator= (const Cond &);
 
    pthread_cond_t _p_cond;
 
    Mutex _mutex;
 
};
 
class RWLock 
{
 
public:
 
    RWLock() throw();
 
    RWLock(const RWLockAttributes& attr);
 
    RWLock(const RWLock& x) throw();
 
    ~RWLock();
 
    void rdlock()
    {
        int res;
        if ((res = ::pthread_rwlock_rdlock(&_p_rwlock)))
            throw Exception("RWLock::rdlock",res);
    }
 
    void wrlock()
    {
        int res;
        if ((res = ::pthread_rwlock_wrlock(&_p_rwlock)))
            throw Exception("RWLock::wrlock",res);
    }
 
    void unlock()
    {
        int res;
        if ((res = ::pthread_rwlock_unlock(&_p_rwlock)))
            throw Exception("RWLock::unlock",res);
    }
 
    pthread_rwlock_t* ptr();
 
private:
    RWLock& operator=(const RWLock&);
 
    pthread_rwlock_t _p_rwlock;
 
    RWLockAttributes _attrs;
 
};
 
class Semaphore 
{
public:
 
    Semaphore():_sem()
    {
    sem_init(&_sem,0,0);
    }
 
 
    ~Semaphore()
    {
    sem_destroy(&_sem);
    }
 
    void wait() throw()
    {
        sem_wait(&_sem);
    }
 
    bool check() throw()
    {
        return sem_trywait(&_sem) == 0;
    }
 
    void post() throw()
    {
    // man page for sem_post:
    // return value of sem_post can be < 0, in which case errno is ERANGE:
    // the  semaphore value would exceed SEM_VALUE_MAX
    //  (the semaphore count is left  unchanged  in this case)
    // Hmmm: do we throw an exception for this pathelogical situation,
    // which compels users to have to catch it?  Naa.
        sem_post(&_sem);
    }
 
    int getValue() throw()
    {
    int val;
        sem_getvalue(&_sem,&val);
    return val;
    }
 
    sem_t* ptr() { return &_sem; }
 
private:
 
    Semaphore(const Semaphore&);
 
    Semaphore& operator=(const Semaphore&);
 
    sem_t _sem;
};
 
class Multisync
{
 
public:
  Multisync(int n);
  void sync();
  void sync(std::string& msg);
  void init();   // to reinitialize
 
private:
  Cond  _co;
  int _n;
  int _count;
  int debug;
 
};
 
 
class Synchronized
{
public:
 
    Synchronized (Cond &cond_): mutexp(0),condp(&cond_)
    {
        condp->lock();
    }
 
    Synchronized (Mutex &mutex_): mutexp(&mutex_),condp(0)
    {
        mutexp->lock();
    }
 
    ~Synchronized ()
    {
        if (condp) condp->unlock();
        else if (mutexp) mutexp->unlock();
    }
 
private:
    Mutex *mutexp;
    Cond *condp;
 
private:
    Synchronized (const Synchronized &);
    Synchronized &operator= (const Synchronized &);
    
};
 
class Autolock
{
public:
 
    Autolock (Cond &cond): _mutexp(0),_condp(&cond)
    {
        cond.lock();
    }
    Autolock (Mutex &mutex): _mutexp(&mutex),_condp(0)
    {
        mutex.lock();
    }
 
    ~Autolock ()
    {
        if (_condp) _condp->unlock();
        else if (_mutexp) _mutexp->unlock();
    }
 
  private:
      Mutex *_mutexp;
      Cond *_condp;
 
  private:
      Autolock (const Autolock &);
      Autolock &operator= (const Autolock &);
    
};
 
class AutoRdLock
{
public:
 
    AutoRdLock (RWLock &rwlock): _rwlock(rwlock)
    {
        _rwlock.rdlock();
    }
 
    ~AutoRdLock ()
    {
        _rwlock.unlock();
    }
 
private:
    RWLock& _rwlock;
 
private:
    AutoRdLock (const Autolock &);
    AutoRdLock &operator= (const Autolock &);
};
 
class AutoWrLock
{
public:
 
    AutoWrLock (RWLock &rwlock): _rwlock(rwlock)
    {
        _rwlock.wrlock();
    }
 
    ~AutoWrLock ()
    {
        _rwlock.unlock();
    }
 
private:
    RWLock& _rwlock;
 
private:
    AutoWrLock (const Autolock &);
    AutoWrLock &operator= (const Autolock &);
};
 
 
}}  // namespace nidas namespace util
 
#endif