framexmit/fxmitmutex.hh

/* -*- mode: c++; c-basic-offset: 3; -*- */
#ifndef _FXMIT_MUTEXOBJ_H
#define _FXMIT_MUTEXOBJ_H
/*----------------------------------------------------------------------*/
/*                                                                      */
/* Module Name: fxmitmutex.h                                            */
/*                                                                      */
/* Module Description: mutex objects                                    */
/*                                                                      */
/* Module Arguments: none                                               */
/*                                                                      */
/* Revision History:                                                    */
/* Rel   Date     Programmer    Comments                                */
/* 1.0   21Nov98  D. Sigg       First release                           */
/*                                                                      */
/* Documentation References:                                            */
/*      Man Pages: fxmitmutex.html                                      */
/*      References: none                                                */
/*                                                                      */
/* Author Information:                                                  */
/* Name          Telephone       Fax             e-mail                 */
/* Daniel Sigg   (509) 372-8132  (509) 372-8137  sigg_d@ligo.mit.edu    */
/*                                                                      */
/* Code Compilation and Runtime Specifications:                         */
/*      Code Compiled on: Ultra-Enterprise, Solaris 5.6                 */
/*      Compiler Used: sun workshop C 4.2                               */
/*      Runtime environment: sparc/solaris                              */
/*                                                                      */
/* Code Standards Conformance:                                          */
/*      Code Conforms to: LIGO standards.       OK                      */
/*                        Lint.                 TBD                     */
/*                        ANSI                  OK                      */
/*                        POSIX                 OK (for UNIX)           */
/*                                                                      */
/* Known Bugs, Limitations, Caveats:                                    */
/*                                                                      */
/*                                                                      */
/*                                                                      */
/*                      -------------------                             */
/*                                                                      */
/*                             LIGO                                     */
/*                                                                      */
/*        THE LASER INTERFEROMETER GRAVITATIONAL WAVE OBSERVATORY.      */
/*                                                                      */
/*                     (C) The LIGO Project, 1996.                      */
/*                                                                      */
/*                                                                      */
/* California Institute of Technology                                   */
/* LIGO Project MS 51-33                                                */
/* Pasadena CA 91125                                                    */
/*                                                                      */
/* Massachusetts Institute of Technology                                */
/* LIGO Project MS 20B-145                                              */
/* Cambridge MA 01239                                                   */
/*                                                                      */
/* LIGO Hanford Observatory                                             */
/* P.O. Box 1970 S9-02                                                  */
/* Richland WA 99352                                                    */
/*                                                                      */
/* LIGO Livingston Observatory                                          */
/* 19100 LIGO Lane Rd.                                                  */
/* Livingston, LA 70754                                                 */
/*                                                                      */
/*----------------------------------------------------------------------*/
/* Header File List: */
#include <memory>
#include "framexmit/fxmittask.h"

namespace framexmit {


   class abstractsemaphore { 
   public:
      typedef enum locktype {
      rdlock = 0,
      wrlock = 1
      };
     //typedef enum locktype locktype; // Not necessary jgz 20080303
   
   
      abstractsemaphore () {
      }
   
      virtual ~abstractsemaphore ();
   
      virtual void lock () = 0;
   
      virtual void readlock () = 0;
   
      virtual void writelock () = 0;
   
      virtual void unlock () = 0;
   
      virtual bool trylock (locktype lck = rdlock) = 0;
   };


   class mutex : public abstractsemaphore {
   public:
   
      mutex () : abstractsemaphore () {
         MUTEX_CREATE (mux);
      };
   
      virtual ~mutex ();
   
      mutex (const mutex&) : abstractsemaphore () {
         MUTEX_CREATE (mux);
      }
   
      mutex& operator= (const mutex& mux) {
         return *this;
      }
   
      virtual void lock () {
         MUTEX_GET (mux);
      }
   
      virtual void readlock () {
         lock();
      }
   
      virtual void writelock () {
         lock ();
      }
   
      virtual void unlock () {
         MUTEX_RELEASE (mux);
      }
   
      virtual bool trylock (locktype lt = rdlock) {
         return (MUTEX_TRY (mux) == 0);
      }
   
   protected:
      mutexID_t         mux;
   };


   class recursivemutex : public mutex {
   public:
   
      recursivemutex () : refcount (0) {
      };
   
      recursivemutex (const recursivemutex& rmux) 
      : mutex (rmux), refcount (0) {
      };
   
      recursivemutex& operator= (const recursivemutex& rm) {
         return *this;
      }
   
      virtual void lock ();
   
      virtual void unlock ();
   
      virtual bool trylock (locktype lck = rdlock);
   
   protected:
      taskID_t          threadID;
      int               refcount;
   };


   class readwritelock : public abstractsemaphore {
   public:
      explicit readwritelock (int Maxuse = -1)
      : maxuse (Maxuse), inuse (0), wrwait (0) {
         MUTEX_CREATE (mux);
         pthread_cond_init (&cond, 0);
      }
   
      virtual ~readwritelock ();
   
      readwritelock (const readwritelock& rw) 
      : abstractsemaphore(), maxuse (rw.maxuse), inuse (0), wrwait (0) {
         MUTEX_CREATE (mux);
         pthread_cond_init (&cond, 0);
      }

      readwritelock& operator= (const readwritelock& rw) {
         return *this;
      }
   
      virtual void readlock ();
   
      virtual void writelock ();
   
      virtual void lock () {
         readlock ();
      }
   
      virtual void unlock ();
   
      bool trylock (locktype lck = rdlock);
   
   private:
      mutexID_t         mux;
      pthread_cond_t    cond;
      int               maxuse;
      int               inuse;
      int               wrwait;
   };


   class semlock {
   public:
      typedef enum locktype {
      rdlock = 0,
      wrlock = 1
      };
      // typedef enum locktype locktype; // Not necessary? jgz20080303

      explicit semlock (abstractsemaphore& sem) 
      : _sem (&sem) {
         _sem->lock();
         // cout << "mutex locked" << endl;
      }
   
      semlock (abstractsemaphore& sem, locktype lck) 
      : _sem (&sem) {
         if (lck == wrlock) {
            _sem->writelock();
         }
         else {
            _sem->readlock();
         }
         // cout << "mutex locked" << endl;
      }
   
      virtual ~semlock ();
   
   private:
      abstractsemaphore*        _sem;
      semlock();
      semlock (const semlock&);
      semlock& operator= (const semlock&);
   };

}

#endif /* _FXMIT_MUTEXOBJ_H */

---