C:/Active/libraries/cxutils/2.0/src/cxutils/mutex.cpp

Go to the documentation of this file.

#include "cxutils/mutex.h"
#include "cxutils/time.h"
#include "cxutils/thread.h"
#include <assert.h>
#include <string>
#include <stdlib.h>
#include <stdio.h>

#ifdef WIN32
    #include <windows.h>
    #ifndef MINGW
        #include <atlbase.h>
    #else
        #define USES_CONVERSION
        #define A2W(x) (x)
        #define W2A(x) (x)
    #endif
#endif

using namespace CxUtils;

unsigned int Mutex::mCount = 0;

Mutex::ScopedLock::ScopedLock(const Mutex* mutex) : mUnlockFlag(true), mpMutex(mutex)
{
    if(mpMutex)
    {
        if(mpMutex->IsLocked())
        {
            mUnlockFlag = false;
        }
        else
        {
            mpMutex->Lock();
        }
    }
}


Mutex::ScopedLock::~ScopedLock() 
{
    if(mpMutex && mUnlockFlag)
    {
        mpMutex->Unlock();
    }
}

/*
void Mutex::ScopedLock::ForceUnlock() 
{
    if(mpMutex && mUnlockFlag)
    {
        mpMutex->Unlock();
        mUnlockFlag = false;
    }
}
*/

Mutex::Mutex(const std::string& name)
{
    mThreadID = 0;
#ifdef WIN32
    mMutex = 0;
#else
    pthread_mutex_init(&mMutex, NULL);
    mSemUnion.mVal = 0;
    mSemUnion.mpArray = NULL;
    mSemUnion.mpBuff = NULL;
    mSemUnion.mpBuffIPC = NULL;
#endif
    Create(name);
}


Mutex::~Mutex()
{
#ifdef WIN32
    if (mMutex)
    {
        ReleaseMutex(mMutex);
        CloseHandle(mMutex);
        mMutex = 0;
    }
#else
    if(IsLocked())
    {
        Unlock();
    }
    
    if( !mName.empty() )
    {
        mSemUnion.mVal = 0;
        mSemUnion.mpArray = NULL;
        mSemUnion.mpBuff = NULL;
        mSemUnion.mpBuffIPC = NULL;
        mName.clear();
    }
    else
    {
        //  Close the mutex
        pthread_mutex_destroy(&mMutex);
    }
#endif
}


void Mutex::Create(const std::string& name)
{
#ifdef WIN32
    if (mMutex)
    {
        ReleaseMutex(mMutex);
        CloseHandle(mMutex);
        mMutex = 0;
    }
#else
    // Make sure we are unlocked.
    Unlock();
    //  Close the mutex
    pthread_mutex_destroy(&mMutex);
    mName.clear();
#endif

#if defined(WIN32)
    mMutex = 0;
    if(name.empty()) 
    {
        mCount++;
        mMutex = CreateMutex(NULL, FALSE, NULL);
        assert(mMutex);
    }
    else 
    {
        USES_CONVERSION; //  Need for UNICODE conversion.
        mMutex = CreateMutex(NULL, FALSE, A2W(name.c_str()));
        assert(mMutex);
    }
#else
    if( !name.empty() )
    {
        mName = name;
        int flag = 0;

        flag = IPC_CREAT;
        
        if( (mSemKey = (key_t)atol( mName.c_str())) == 0)
        {
            // Convert letters in string to a unique number.
            char* buffer = new char[mName.size() * 3 + 1];
            char* ptr = buffer;
            for(unsigned int i = 0; i < (unsigned int)mName.size(); i++)
            {
                sprintf(ptr, "%.03d", (int)mName.c_str()[i]);
                ptr += 3;
            }
            if( (mSemKey = (key_t)atol( buffer )) == 0)
            {
                mName.clear();
                printf("ERROR: Failed to Create Global Mutex\n");
                assert("Failed to Create Mutex");
                exit(0);
            }
        }

        // See if the mutex has already been created.
        flag = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP;
        // Try get access to semaphore if it already exists
        // but with read/write access for owner and group.
        mSemID = (int)semget( mSemKey, 1, flag );

        // If == -1 then the semaphore doesn't exist and
        // we need to create it.
        if( mSemID < 0)
        {
            mSemID = (int)semget( mSemKey, 1, flag | IPC_CREAT);
            if(mSemID < 0)
            {
                mName.clear();
                printf("ERROR: Failed to Create Global Mutex\n");
                exit(0);
            }
            // Set the initial state of the semaphore
            mSemUnion.mVal = 1;
            if( semctl( mSemID, 0, SETVAL, mSemUnion) == -1)
            {
                mName.clear();
                printf("ERROR: Failed to Create Global Mutex\n");
                exit(0);
            }
        }        
        //printf( "Mutex Created!\n");
    }
    else
    {
        pthread_mutex_init(&mMutex, NULL);
    }
#endif
}


bool Mutex::Lock(unsigned long wait /*= INFINITE */) const
{
    if(mThreadID != 0)
    {
        Thread::ID callingID = Thread::GetCurrentThreadID();
        if(mThreadID == callingID)
        {
            assert("Created Mutex Deadlock!" && 0);
            return true;
        }
    }
#ifdef WIN32
    if (mMutex) 
    {
        DWORD result = WaitForSingleObject(mMutex, wait);
        if(result == WAIT_TIMEOUT)
        {
            return false;
        }
        *((ID *)(&mThreadID)) = Thread::GetCurrentThreadID();
        return true;
    }
    return false;
#else
    if( !mName.empty() )
    {
        struct sembuf buff;          
        unsigned int startTimeMs = GetTimeMs();
        // Decrement the operation signal to
        // mark entering mutex.
        buff.sem_num = 0;
        buff.sem_op = -1;  // Block/Wait
        buff.sem_flg = SEM_UNDO;
        
        struct timespec delay;
        delay.tv_sec = 0;
        delay.tv_nsec = 1000;
        while(GetTimeMs() - startTimeMs < wait || wait == INFINITE)
        {
            if( semop( mSemID, &buff, 1) >= 0 )
            {
                //printf("Mutex Locked!\n");
                *((ID *)(&mThreadID))  = Thread::GetCurrentThreadID();
                return true;
            }
            nanosleep(&delay, NULL);
        } 
        //printf("ERROR: Failed to Lock Global Mutex!\n");
        //assert("Failed to Lock Global Mutex" && 0);
        return false;
    }
    else
    {
        pthread_mutex_t *mut = (pthread_mutex_t *)(&mMutex);
        pthread_mutex_lock(mut);
    }

    *((ID *)(&mThreadID))  = Thread::GetCurrentThreadID();

    return true;
#endif
}


void Mutex::Unlock() const
{
    if(mThreadID != 0 && Thread::GetCurrentThreadID() == mThreadID)
    {
        *((ID *)(&mThreadID)) = 0;
    }
#ifdef WIN32
    if(mMutex)
    {
        ReleaseMutex(mMutex);        
    }
#else
    if( !mName.empty() )
    {
        struct sembuf buff;          

        // Increment the operation to signal leaving
        // the critical section.
        buff.sem_num = 0;
        buff.sem_op = 1;
        buff.sem_flg = SEM_UNDO;

        if( semop( mSemID, &buff, 1) != 0)
        {
            //printf("Failed to Unlock Mutex!\n");
        }
        //printf( "Mutex Unlocked!\n");
    }
    else
    {
        pthread_mutex_t *mut = (pthread_mutex_t *)(&mMutex);
        pthread_mutex_unlock(mut);
    }
#endif
}


bool Mutex::IsLocked() const
{
    if(mThreadID == Thread::GetCurrentThreadID())
    {
        return true;
    }
    return false;
}

/*  End of File */