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             jack_error("JackBasePosixMutex::Lock mutex already locked by thread = %d", current_thread);
  55             return false;
  56         }
  57     }
  58
  59     bool JackBasePosixMutex::Trylock()
  60     {
  61         pthread_t current_thread = pthread_self();
  62
  63         if (!pthread_equal(current_thread, fOwner)) {
  64             int res = pthread_mutex_trylock(&fMutex);
  65             if (res == 0) {
  66                 fOwner = current_thread;
  67                 return true;
  68             } else {
  69                 return false;
  70             }
  71         } else {
  72             jack_error("JackBasePosixMutex::Trylock mutex already locked by thread = %d", current_thread);
  73             return false;
  74         }
  75     }
  76
  77     bool JackBasePosixMutex::Unlock()
  78     {
  79         if (pthread_equal(pthread_self(), fOwner)) {
  80             fOwner = 0;
  81             int res = pthread_mutex_unlock(&fMutex);
  82             if (res == 0) {
  83                 return true;
  84             } else {
  85                 jack_error("JackBasePosixMutex::Unlock res = %d", res);
  86                 return false;
  87             }
  88         } else {
  89             jack_error("JackBasePosixMutex::Unlock mutex not locked by thread = %d owner %d", pthread_self(), fOwner);
  90             return false;
  91         }
  92     }
  93
  94     JackPosixMutex::JackPosixMutex(const char* name)
  95     {
  96         // Use recursive mutex
  97         pthread_mutexattr_t mutex_attr;
  98         int res;
  99         res = pthread_mutexattr_init(&mutex_attr);
 100         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not init the mutex attribute"));
 101         res = pthread_mutexattr_settype(&mutex_attr, PTHREAD_MUTEX_RECURSIVE);
 102         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not settype the mutex"));
 103         res = pthread_mutex_init(&fMutex, &mutex_attr);
 104         ThrowIf(res != 0, JackException("JackBasePosixMutex: could not init the mutex"));
 105         pthread_mutexattr_destroy(&mutex_attr);
 106     }
 107
 108     JackPosixMutex::~JackPosixMutex()
 109     {
 110         pthread_mutex_destroy(&fMutex);
 111     }
 112
 113     bool JackPosixMutex::Lock()
 114     {
 115         int res = pthread_mutex_lock(&fMutex);
 116         if (res != 0) {
 117             jack_log("JackPosixMutex::Lock res = %d", res);
 118         }
 119         return (res == 0);
 120     }
 121
 122     bool JackPosixMutex::Trylock()
 123     {
 124         return (pthread_mutex_trylock(&fMutex) == 0);
 125     }
 126
 127     bool JackPosixMutex::Unlock()
 128     {
 129         int res = pthread_mutex_unlock(&fMutex);
 130         if (res != 0) {
 131             jack_log("JackPosixMutex::Unlock res = %d", res);
 132         }
 133         return (res == 0);
 134     }
 135
 136
 137 } // namespace