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) throw(Exception);
    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) throw(Exception);
    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) throw(Exception);
    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) throw(Exception);

    Mutex(const Mutex& x) throw();

    ~Mutex();

    void lock() throw(Exception)
    {
        int res;
        if((res = ::pthread_mutex_lock(&_p_mutex)))
            throw Exception("Mutex::lock",res);
    }

    void unlock() throw(Exception)
    {
        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() throw(Exception)
    {
        _mutex.lock();
    }

    void unlock() throw(Exception)
    {
        _mutex.unlock();
    }

    void signal() throw(Exception)
    {
        // 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() throw(Exception);

private:
    Cond &operator= (const Cond &);

    pthread_cond_t _p_cond;

    Mutex _mutex;

};

class RWLock 
{

public:

    RWLock() throw();

    RWLock(const RWLockAttributes& attr) throw(Exception);
    RWLock(const RWLock& x) throw();

    ~RWLock();

    void rdlock() throw(Exception)
    {
        int res;
        if ((res = ::pthread_rwlock_rdlock(&_p_rwlock)))
            throw Exception("RWLock::rdlock",res);
    }

    void wrlock() throw(Exception)
    {
        int res;
        if ((res = ::pthread_rwlock_wrlock(&_p_rwlock)))
            throw Exception("RWLock::wrlock",res);
    }

    void unlock() throw(Exception)
    {
        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_) throw(Exception): mutexp(0),condp(&cond_)
    {
        condp->lock();
    }
    Synchronized (Mutex &mutex_) throw(Exception): 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) throw(Exception): _mutexp(0),_condp(&cond)
    {
        cond.lock();
    }
    Autolock (Mutex &mutex) throw(Exception): _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) throw(Exception): _rwlock(rwlock)
    {
        _rwlock.rdlock();
    }

    ~AutoRdLock ()
    {
        _rwlock.unlock();
    }

private:
    RWLock& _rwlock;

private:
    AutoRdLock (const Autolock &);
    AutoRdLock &operator= (const Autolock &);
};

class AutoWrLock
{
public:

    AutoWrLock (RWLock &rwlock) throw(Exception): _rwlock(rwlock)
    {
        _rwlock.wrlock();
    }

    ~AutoWrLock ()
    {
        _rwlock.unlock();
    }

private:
    RWLock& _rwlock;

private:
    AutoWrLock (const Autolock &);
    AutoWrLock &operator= (const Autolock &);
};


}}  // namespace nidas namespace util

#endif