posix/JackPosixMutex.cpp

   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 #include "JackPosixMutex.h"
  23 #include "JackError.h"
  24
  25 namespace Jack
  26 {
  27
  28     JackBasePosixMutex::JackBasePosixMutex(const char* name)
  29         :fOwner(0)
  30     {
  31         int res = pthread_mutex_init(&fMutex, NULL);
  32         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not init the mutex"));
  33     }
  34
  35     JackBasePosixMutex::~JackBasePosixMutex()
  36     {
  37         pthread_mutex_destroy(&fMutex);
  38     }
  39
  40     bool JackBasePosixMutex::Lock()
  41     {
  42         pthread_t current_thread = pthread_self();
  43
  44         if (!pthread_equal(current_thread, fOwner)) {
  45             int res = pthread_mutex_lock(&fMutex);
  46             if (res == 0) {
  47                 fOwner = current_thread;
  48                 return true;
  49             } else {
  50                 jack_error("JackBasePosixMutex::Lock res = %d", res);
  51                 return false;
  52             }
  53         } else {
  54             return false;
  55         }
  56     }
  57
  58     bool JackBasePosixMutex::Trylock()
  59     {
  60         pthread_t current_thread = pthread_self();
  61
  62         if (!pthread_equal(current_thread, fOwner)) {
  63             int res = pthread_mutex_trylock(&fMutex);
  64             if (res == 0) {
  65                 fOwner = current_thread;
  66                 return true;
  67             } else {
  68                 return false;
  69             }
  70         } else {
  71             return false;
  72         }
  73     }
  74
  75     bool JackBasePosixMutex::Unlock()
  76     {
  77         if (pthread_equal(pthread_self(), fOwner)) {
  78             fOwner = 0;
  79             int res = pthread_mutex_unlock(&fMutex);
  80             if (res == 0) {
  81                 return true;
  82             } else {
  83                 jack_error("JackBasePosixMutex::Unlock res = %d", res);
  84                 return false;
  85             }
  86         } else {
  87             return false;
  88         }
  89     }
  90
  91     JackPosixMutex::JackPosixMutex(const char* name)
  92     {
  93         // Use recursive mutex
  94         pthread_mutexattr_t mutex_attr;
  95         int res;
  96         res = pthread_mutexattr_init(&mutex_attr);
  97         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not init the mutex attribute"));
  98         res = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
  99         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not settype the mutex"));
 100         res = pthread_mutex_init(&fMutex, &mutex_attr);
 101         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not init the mutex"));
 102         pthread_mutexattr_destroy(&mutex_attr);
 103     }
 104
 105     JackPosixMutex::~JackPosixMutex()
 106     {
 107         pthread_mutex_destroy(&fMutex);
 108     }
 109
 110     bool JackPosixMutex::Lock()
 111     {
 112         int res = pthread_mutex_lock(&fMutex);
 113         if (res != 0) {
 114             jack_log("JackPosixMutex::Lock res = %d", res);
 115         }
 116         return (res == 0);
 117     }
 118
 119     bool JackPosixMutex::Trylock()
 120     {
 121         return (pthread_mutex_trylock(&fMutex) == 0);
 122     }
 123
 124     bool JackPosixMutex::Unlock()
 125     {
 126         int res = pthread_mutex_unlock(&fMutex);
 127         if (res != 0) {
 128             jack_log("JackPosixMutex::Unlock res = %d", res);
 129         }
 130         return (res == 0);
 131     }
 132
 133
 134 } // namespace