posix/JackPosixMutex.h

   1 /*
   2  Copyright (C) 2006 Grame
   3
   4  This library is free software; you can redistribute it and/or
   5  modify it under the terms of the GNU Lesser General Public
   6  License as published by the Free Software Foundation; either
   7  version 2.1 of the License, or (at your option) any later version.
   8
   9  This library is distributed in the hope that it will be useful,
  10  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  Lesser General Public License for more details.
  13
  14  You should have received a copy of the GNU Lesser General Public
  15  License along with this library; if not, write to the Free Software
  16  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17
  18  Grame Research Laboratory, 9 rue du Garet, 69001 Lyon - France
  19  grame@grame.fr
  20 */
  21
  22 #ifndef __JackPosixMutex__
  23 #define __JackPosixMutex__
  24
  25 #include <pthread.h>
  26 #include <stdio.h>
  27 #include <assert.h>
  28 #include "JackError.h"
  29
  30 namespace Jack
  31 {
  32 /*!
  33 \brief Mutex abstraction.
  34 */
  35
  36
  37 class JackBasePosixMutex
  38 {
  39
  40     protected:
  41
  42         pthread_mutex_t fMutex;
  43
  44     public:
  45
  46         JackBasePosixMutex()
  47         {
  48             pthread_mutex_init(&fMutex, NULL);
  49         }
  50
  51         virtual ~JackBasePosixMutex()
  52         {
  53             pthread_mutex_destroy(&fMutex);
  54         }
  55
  56         void Lock()
  57         {
  58             int res = pthread_mutex_lock(&fMutex);
  59             if (res != 0)
  60                 jack_error("JackBasePosixMutex::Lock res = %d", res);
  61         }
  62
  63         bool Trylock()
  64         {
  65             return (pthread_mutex_trylock(&fMutex) == 0);
  66         }
  67
  68         void Unlock()
  69         {
  70             int res = pthread_mutex_unlock(&fMutex);
  71             if (res != 0)
  72                 jack_error("JackBasePosixMutex::Unlock res = %d", res);
  73         }
  74
  75 };
  76
  77 class JackPosixMutex
  78 {
  79
  80     protected:
  81
  82         pthread_mutex_t fMutex;
  83
  84     public:
  85
  86         JackPosixMutex()
  87         {
  88             // Use recursive mutex
  89             pthread_mutexattr_t mutex_attr;
  90             int res;
  91             res = pthread_mutexattr_init(&mutex_attr);
  92             assert(res == 0);
  93             res = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
  94             assert(res == 0);
  95             res = pthread_mutex_init(&fMutex, &mutex_attr);
  96             assert(res == 0);
  97             res = pthread_mutexattr_destroy(&mutex_attr);
  98             assert(res == 0);
  99         }
 100
 101         virtual ~JackPosixMutex()
 102         {
 103             pthread_mutex_destroy(&fMutex);
 104         }
 105
 106         void Lock()
 107         {
 108             int res = pthread_mutex_lock(&fMutex);
 109             if (res != 0)
 110                 jack_error("JackPosixMutex::Lock res = %d", res);
 111         }
 112
 113         bool Trylock()
 114         {
 115             return (pthread_mutex_trylock(&fMutex) == 0);
 116         }
 117
 118         void Unlock()
 119         {
 120             int res = pthread_mutex_unlock(&fMutex);
 121             if (res != 0)
 122                 jack_error("JackPosixMutex::Unlock res = %d", res);
 123         }
 124
 125 };
 126
 127
 128 } // namespace
 129
 130 #endif