C:/rwlock/system_abstraction.h

Go to the documentation of this file.

#ifndef __SYSTEM_ABSTRACTION_HH_INCLUDDED__
#define __SYSTEM_ABSTRACTION_HH_INCLUDDED__ 

#ifdef WIN32
#include <windows.h>
#include <assert.h>

class SystemLock
{
        CRITICAL_SECTION cs;
public:
        SystemLock()    { InitializeCriticalSection(&cs); }
        ~SystemLock()   { DeleteCriticalSection(&cs); }

        void lock(void)         { EnterCriticalSection(&cs); }
        void unlock(void)       { LeaveCriticalSection(&cs); }
};

class SystemThread
{
        HANDLE handle;
        void * (*thread_f)(void *);
        void *thread_param;

        static DWORD WINAPI ThreadProc(LPVOID lpParameter)
        {
                SystemThread *this_ptr=(SystemThread *)lpParameter;
                void * (*f)(void *) = this_ptr->thread_f;
                void *param = this_ptr->thread_param;
                return (DWORD)f(param);
        }
public:
        SystemThread(void *(*f)(void *), void *param) : thread_f(f), thread_param(param)
        {
                DWORD thrid;
                handle = CreateThread(NULL, 0, &ThreadProc, (void*)this, 0, &thrid);
                assert(handle);
        }
        ~SystemThread() { join(INFINITE); CloseHandle(handle); }
        int join(unsigned milliseconds = INFINITE)
        {
                switch(WaitForSingleObject(handle, milliseconds))
                {
                        case WAIT_TIMEOUT:
                                return 1;
                        case WAIT_OBJECT_0:
                                return 0;
                        case WAIT_ABANDONED:
                        default:
                                break;
                }
                return -1;
        }
};

inline void SystemSleep(unsigned millisec=0)
{
        Sleep(millisec);
};

inline void thread_yield(void)
{
        Sleep(0);
}

#else  // #ifdef WIN32

#include <unistd.h>
#include <pthread.h>
#include <sched.h>

class SystemLock
{
        pthread_mutex_t mutex;
public:
        SystemLock()        { pthread_mutex_init(&mutex, NULL); }
        ~SystemLock()       { pthread_mutex_destroy(&mutex); }

        void lock(void)         { pthread_mutex_lock(&mutex); }
        void unlock(void)       { pthread_mutex_unlock(&mutex); }
};

class SystemThread
{
        pthread_t thread;
        void * (*thread_f)(void *);
        void *thread_param;

        static void * ThreadProc(void *parameter)
        {
                SystemThread *this_ptr=(SystemThread *)parameter;
                return (void*)this_ptr->thread_f(this_ptr->thread_param);
        }
public:
        SystemThread(void * (*f)(void *), void *param) : thread_f(f), thread_param(param)
        {
                assert( pthread_create( &thread, NULL, &SystemThread::ThreadProc, (void*)this)==0 );
        }
        ~SystemThread() { join(); }
        int join(unsigned milliseconds = ~(unsigned)0)
        {
                return  pthread_join(thread, NULL);
        }
};

inline void SystemSleep(unsigned millisec=0)
{
    struct timeval tv;
    tv.tv_sec = millisec / 1000;
    tv.tv_usec = (millisec % 1000) * 1000;
        select(0, NULL, NULL, NULL, &tv);
};

inline void thread_yield(void)
{
        sched_yield();
}

#endif // #ifdef WIN32

#endif // #ifndef __SYSTEM_ABSTRACTION_HH_INCLUDDED__

---