---

threadsPAL.hpp

Go to the documentation of this file.

#ifndef __THREADS_POSIX_PAL_HPP__
#define __THREADS_POSIX_PAL_HPP__

#include <pthread.h>
#include <semaphore.h>
#include <string.h>
#include <assert.h>

namespace lfc
{
namespace posixPAL
{


namespace threads
{

const int MAX_ERROR_CODE = 1;

enum ErrorCodes
{
    errOk,
    errGeneric,
};


extern const char *messagesTable[MAX_ERROR_CODE + 1];

void* __threadProc(void *);

struct __StartThreadInfo
{
    void (*proc)(void *);
    void *pData;
};

struct ThreadHandle
{
    ::pthread_t handle;
    bool valid;

    ThreadHandle() : valid(false) {}
    bool isNull() const { return !valid; }
    
private:
    void operator==(const ThreadHandle &) const;    // disabled, no implementation
};

struct MutexHandle
{
    ::pthread_mutex_t handle;
    bool valid;

    MutexHandle() : valid(false) {}
    bool isNull() const { return !valid; }
    
private:
    void operator==(const MutexHandle &) const; // disabled, no implementation
};


struct SemHandle
{
    ::sem_t handle;
    bool valid;

    SemHandle() : valid(false) {}
    bool isNull() const { return !valid; }
    
private:
    void operator==(const SemHandle &) const;   // disabled, no implementation
};

typedef ::pthread_key_t TLSKey;


const ThreadHandle NULL_THREAD_HANDLE = ThreadHandle();

const MutexHandle NULL_MUTEX_HANDLE = MutexHandle();

const SemHandle NULL_SEM_HANDLE = SemHandle();

const int
    priorityMin = -1,
    priorityNormal = 0,
    priorityMax = 1;
    


inline int init()
{
    return errOk;
}



inline int cleanup()
{
    return errOk;
}



inline int createThread(ThreadHandle &handle, void (*proc)(void *), void *pData)
{
    assert(handle.valid == false);

    __StartThreadInfo *pInfo = new __StartThreadInfo;
    pInfo->proc = proc;
    pInfo->pData = pData;
    
    ThreadHandle h;
    if( ::pthread_create(&h.handle, NULL, &__threadProc, pInfo) != 0 )
        return errGeneric;

    h.valid = true;
    handle = h;

    return errOk;
}



inline int closeThread(ThreadHandle &handle)
{
    assert(handle.valid == true);
    
    if(::pthread_detach(handle.handle) == 0)
    {
        handle.valid = false;
        return errOk;
    }
    else
        return errGeneric;
}


inline int getCurrentThread(ThreadHandle &handle)
{
    // my man page doesn't say anything about errs.
    // it just says pthread_self returns the calling thread's handle
    handle.handle = ::pthread_self();    
    handle.valid = true;
    return errOk;
}



inline int destroyThread(const ThreadHandle &handle)
{
    assert(handle.valid == true);
    return ::pthread_cancel(handle.handle) == 0 ? errOk : errGeneric;
}


inline int joinThread(const ThreadHandle &handle)
{
    assert(handle.valid == true);

    if( ::pthread_join(handle.handle, NULL) == 0 )
        return errOk;
    else
        return errGeneric;
}



inline int setThreadPriority(const ThreadHandle &handle, int priority)
{
    assert(handle.valid == true);

    sched_param param;
    
    ::memset(&param, 0, sizeof(param));

    switch(priority)
    {
    case priorityMin:
        param.sched_priority = ::sched_get_priority_min(SCHED_OTHER);
        break;
        
    case priorityNormal:
        param.sched_priority =
            (::sched_get_priority_min(SCHED_OTHER) +
            ::sched_get_priority_max(SCHED_OTHER)) / 2;
        break;
        
    case priorityMax:
        param.sched_priority = ::sched_get_priority_max(SCHED_OTHER);
        break;
        
    default:
        return errGeneric;
    }

    if(::pthread_setschedparam(handle.handle, SCHED_OTHER, &param) != 0)
        return errGeneric;

    return errOk;
}



inline int yield()
{
    if( ::sched_yield() == 0)
        return errOk;

    return errGeneric;
}


inline int sleep(long miliseconds)
{
    timespec ts;
    ts.tv_sec = miliseconds / 1000;
    ts.tv_nsec = (miliseconds % 1000) * 1000000;
    ::nanosleep(&ts, NULL);

    return errOk;
}



inline int allocTLS(TLSKey &key)
{
    TLSKey k;
    
    if( ::pthread_key_create(&k, NULL) != 0)
        return errGeneric;

    key = k;
    return errOk;
}


inline int freeTLS(TLSKey key)
{
    return ::pthread_key_delete(key) == 0 ? errOk : errGeneric;
}



inline int setTLS(TLSKey key, void *value)
{
    return  ::pthread_setspecific(key, value) == 0 ? errOk : errGeneric;
}



inline int getTLS(TLSKey key, void *&value)
{
    void *v = ::pthread_getspecific(key);
    if( v == NULL)
        return errGeneric;

    value = v;
    return errOk;
}



// 
int createMutex(MutexHandle &handle);


inline int closeMutex(MutexHandle &handle)
{
    assert(handle.valid == true);

    if(::pthread_mutex_destroy(&handle.handle) == 0)
    {
        handle.valid = false;
        return errOk;
    }
    else
        return errGeneric;
}



inline int lockMutex(MutexHandle &handle)
{
    assert(handle.valid == true);
    return ( ::pthread_mutex_lock(&handle.handle) == 0) ? errOk : errGeneric;
}



inline int tryLockMutex(MutexHandle &handle, bool &bLocked)
{
    assert(handle.valid == true);
    bLocked = ::pthread_mutex_trylock(&handle.handle) == 0;
    return errOk;
}


inline int unlockMutex(MutexHandle &handle)
{
    assert(handle.valid == true);
    return ::pthread_mutex_unlock(&handle.handle) == 0 ? errOk : errGeneric;
}



inline int createSemaphore(SemHandle &handle, long count)
{    
    assert(handle.valid == false);
    
    if( ::sem_init(&handle.handle, 0, count) == -1)
        return errGeneric;

    handle.valid = true;
    return errOk;
}



inline int closeSemaphore(SemHandle &handle)
{
    assert(handle.valid == true);

    if(::sem_destroy(&handle.handle) == 0)
    {
        handle.valid = false;
        return errOk;
    }
    else
        return errGeneric;
}



inline int waitSemaphore(SemHandle &handle)
{
    assert(handle.valid == true);
    return ( ::sem_wait(&handle.handle) == 0 ) ? errOk : errGeneric;
}


inline int tryWaitSemaphore(SemHandle &handle, bool &bLocked)
{
    assert(handle.valid == true);
    bLocked = (::sem_trywait(&handle.handle) == 0);
    return errOk;
}


inline int postSemaphore(SemHandle &handle)
{
    return (::sem_post(&handle.handle) == 0) ? errOk : errGeneric;
}



inline const char *message(int index)
{
    assert(index >= 0 && index <= MAX_ERROR_CODE);
    return messagesTable[index];
}


} // namespace posixPAL::threads
} // namespace posixPAL

namespace pal = posixPAL;

} // namespace lfc


#endif  // __THREADS_POSIX_PAL_HPP__

---