JSemaphore_Linux.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library 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
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/

namespace cmlabs {


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#undef HANDLE
#define HANDLE pthread_cond_t*

JSemaphore::JSemaphore(JString semName) {

        count=0;
        name = semName;

        hSemaphore = new pthread_cond_t;
        pthread_cond_init(hSemaphore, NULL);

        mutex = new pthread_mutex_t;
        pthread_mutex_init(mutex, NULL);
   
}

JSemaphore::~JSemaphore() {
        pthread_cond_destroy(hSemaphore);
        delete(hSemaphore);
        //   sem_destroy(&hSemaphore);
        pthread_mutex_destroy(mutex);
        delete(mutex);
}


bool JSemaphore::wait(long ms)
{
        bool res;
        struct timeval now;
        struct timespec timeout;
        JTime t;
        long x;
        int ret = 0;

        pthread_mutex_lock(mutex);
        if (count > 0) {
                res = true;
        }
        else if (ms < 0) {
                res = (pthread_cond_wait(hSemaphore, mutex) == 0);
        }
        else if (ms == 0) {
                calcTimeout(timeout, now, ms);
                ret = pthread_cond_timedwait(hSemaphore, mutex, &timeout);
                if (ret == EINVAL) {
                        #ifdef DEVELOPMENT
                //      printf("\n\n   ######## Semaphore [%d] got invalid params: {%d.%.9d >? %d.%.6d000} #########\n\n", (int)ms, timeout.tv_sec, timeout.tv_nsec, now.tv_sec, now.tv_usec);
                        #endif
                }
                res = (ret == 0);
        }
        else {
                calcTimeout(timeout, now, ms);
                ret = pthread_cond_timedwait(hSemaphore, mutex, &timeout);
                if (ret == EINVAL) {
                        #ifdef DEVELOPMENT
                //      printf("\n\n   ######## Semaphore [%d] got invalid params: {%d.%.9d >? %d.%.6d000} #########\n\n", (int)ms, timeout.tv_sec, timeout.tv_nsec, now.tv_sec, now.tv_usec);
                        #endif
                }
                res = (ret == 0);
        }

        if (res) {
                count--;
                pthread_mutex_unlock(mutex);
        //      printf("-[%d]", count); fflush(stdout);
                return true;
        }
        else {
                pthread_mutex_unlock(mutex);
                if ((ms > 0) && (t.getAge() < (ms*0.9))) {
                        #ifdef DEVELOPMENT
                //      printf("\n\n   ######## Semaphore too early %.3f < %d [%d] {%d, %d, %d}#########\n\n", t.getMicroAge()/1000.0, ms, ret, ETIMEDOUT, EINVAL, EPERM);
                //      wait(2000);
                        #endif
                }
                return false;
        }

//   sem_wait(&hSsemaphore);
}

bool JSemaphore::post()
{
        pthread_mutex_lock(mutex);
        count++;
        bool res = (pthread_cond_signal(hSemaphore) == 0);
        pthread_mutex_unlock(mutex);
//      printf("+[%d]", count); fflush(stdout);
        return res;
}

bool JSemaphore::tryWait()
{
        return wait(0);
}





JSingleSemaphore::JSingleSemaphore() {

        hSemaphore = new pthread_cond_t;
        pthread_cond_init(hSemaphore, NULL);

        mutex = new pthread_mutex_t;
        pthread_mutex_init(mutex, NULL);
   
}

JSingleSemaphore::~JSingleSemaphore() {
        pthread_cond_destroy(hSemaphore);
        delete(hSemaphore);
        //   sem_destroy(&hSemaphore);
        pthread_mutex_destroy(mutex);
        delete(mutex);
}


bool JSingleSemaphore::wait(long ms)
{
        bool res;
        struct timeval now;
        struct timespec timeout;
        int ret = 0;
        long x;

        pthread_mutex_lock(mutex);
        if (ms < 0) {
                res = (pthread_cond_wait(hSemaphore, mutex) == 0);
        }
        else if (ms == 0) {
                calcTimeout(timeout, now, ms);
                ret = pthread_cond_timedwait(hSemaphore, mutex, &timeout);
                if (ret == EINVAL) {
                        // printf("\n\n   ######## Semaphore got invalid params: {%d.%.9d >? %d.%.6d000} #########\n\n", timeout.tv_sec, timeout.tv_nsec, now.tv_sec, now.tv_usec);
                }
                res = (ret == 0);
        }
        else {
                calcTimeout(timeout, now, ms);
                ret = pthread_cond_timedwait(hSemaphore, mutex, &timeout);
                if (ret == EINVAL) {
                        // printf("\n\n   ######## Semaphore got invalid params: {%d.%.9d >? %d.%.6d000} #########\n\n", timeout.tv_sec, timeout.tv_nsec, now.tv_sec, now.tv_usec);
                }
                res = (ret == 0);
        }
        pthread_mutex_unlock(mutex);

        if (res) {
                return true;
        }
        else
                return false;

//   sem_wait(&hSsemaphore);
}

bool JSingleSemaphore::postToAll()
{
        pthread_mutex_lock(mutex);
        bool res = (pthread_cond_broadcast(hSemaphore) == 0);
        pthread_mutex_lock(mutex);
        return res;
}

bool JSingleSemaphore::tryWait()
{
        return wait(0);
}






JMutex::JMutex() {

        pthread_mutexattr_t mattr;
        int ret = pthread_mutexattr_init(&mattr); 
        //   pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_ERRORCHECK);
        pthread_mutexattr_settype(&mattr, PTHREAD_MUTEX_RECURSIVE);

        mutex = new pthread_mutex_t;
        pthread_mutex_init(mutex, &mattr);

        semaphore = new pthread_cond_t;
        pthread_cond_init(semaphore, NULL);

        semaphoremutex = new pthread_mutex_t;
        pthread_mutex_init(semaphoremutex, NULL);
}

JMutex::~JMutex() {
        pthread_mutex_destroy(mutex);
        delete(mutex);

        pthread_cond_destroy(semaphore);
        delete(semaphore);
        pthread_mutex_destroy(semaphoremutex);
        delete(semaphoremutex);
}

bool JMutex::EnterMutex(long ms) const {
        return enterMutex(ms);
}

bool JMutex::enterMutex(long ms) const {

        JTime t;
        int res = pthread_mutex_trylock(mutex);
        if (res == 0) {
                // Clear semaphore ???
                return true;
        }

        // Mutex is already locked, wait for the semaphore signal...
        struct timeval now;
        struct timespec timeout;
        calcTimeout(timeout, now, ms);

        int sres = 0;
        if (pthread_mutex_lock(semaphoremutex) != 0) {
                printf("JMutex::enterMutex failed to obtain own mutex\n");
                return false;
        }
        while ((res = pthread_mutex_trylock(mutex)) != 0) {
                if (sres == ETIMEDOUT)
                        break;
                sres = pthread_cond_timedwait(semaphore, semaphoremutex, &timeout);
        }
        pthread_mutex_unlock(semaphoremutex);

        // Now, try again...
        if (res == 0)
                return true;

//      printf("JMutex::EnterMutex(%d) timeout after %.3f ms: %d (%d %d)\n%s\n", (int) ms, t.getMicroAge()/1000.0, sres, ETIMEDOUT, EINTR, (char*) JThread::getProgramTrace().printListLine("\n"));
//      wait(3000);
        return false;

/*      JTime start;
        int res = pthread_mutex_lock(mutex);
        if (res != 0) {
                printf("JMutex::EnterMutex failed to obtain own mutex\n");
                return false;
        }

        if (!isLocked) {
                *(bool*)p = true;
                res = pthread_mutex_unlock(mutex);
                return true;
        }

        struct timeval now;
        struct timespec timeout;
        calcTimeout(timeout, now, ms);

        res = pthread_cond_timedwait(semaphore, mutex, &timeout);
        if (res == 0) {
                *(bool*)p = true;
        }
        else {
                if (res != ETIMEDOUT)
                        printf("JMutex::EnterMutex wait returned: %d (%d) after %.3f ms\n", res, EINTR, start.getMicroAge()/1000.0);
        //      else
        //              printf("JMutex::EnterMutex timeout after %.3f ms\n%s\n", start.getMicroAge()/1000.0, (char*) JThread::getProgramTrace().printListLine("\n"));
        }
        
        res = pthread_mutex_unlock(mutex);
        return (res == 0);*/
}

bool JMutex::LeaveMutex() const {
        return leaveMutex();
}

bool JMutex::leaveMutex() const {

        int res = pthread_mutex_unlock(mutex);
        if (res == EPERM) {
        //      JString str;
        //      printf("JMutex::LeaveMutex failed to unlock mutex - not owner\n%s\n\n", (char*) JThread::getProgramTrace().printListLine("\n"));
        //      str.wait(3000);
                return false;
        }
        else if (res != 0) {
                printf("JMutex::LeaveMutex failed to unlock mutex - not initialised\n");
                return false;
        }

        // Signal semaphore
        pthread_mutex_lock(semaphoremutex);
        pthread_cond_signal(semaphore);
        pthread_mutex_unlock(semaphoremutex);

        return true;
}


#ifndef WIN32
bool calcTimeout(struct timespec &timeout, struct timeval &now, long ms) {

        if (gettimeofday(&now, NULL) != 0)
                return false;
        ldiv_t div_result;
        div_result = ldiv( ms, 1000 );
        timeout.tv_sec = now.tv_sec + div_result.quot;
        long x = now.tv_usec + (div_result.rem * 1000);
        if (x >= 1000000) {
                timeout.tv_sec++;
                x -= 1000000;
        }
        timeout.tv_nsec = x * 1000;
        return true;
}
#endif

} // namespace cmlabs

---