source: libcf++/trunk/src/task.cpp@ 11

/**
 * @file task.cpp
 * @author myusgun@gmail.com
 * @brief task
 */
#include "cf/task.h"
#include "cf/memory.h"

#ifdef _ON_WINDOWS
# include <windows.h>
# include <process.h>
typedef HANDLE              thread_t;
typedef CRITICAL_SECTION    mutex_t;
# define THREAD_RETURN      cf::ulong_t /**< return-type of thread worker */
# define THREAD_CALL        __stdcall
#else
# include <string.h>
# include <unistd.h>
# include <pthread.h>
# include <errno.h>
typedef pthread_t           thread_t;
typedef pthread_mutex_t     mutex_t;
# define THREAD_RETURN      void *  /**< return-type of thread worker */
# define THREAD_CALL
#endif

typedef THREAD_RETURN(THREAD_CALL * THREAD_WORKER)(cf::void_t *);

/*--------------------------------------------------------------*/
static inline THREAD_RETURN THREAD_CALL Runner(cf::void_t * arg)
{
    cf::task::thread::THREAD_CTX * ctx = reinterpret_cast<cf::task::thread::THREAD_CTX *>(arg);

    ctx->mReturned = ctx->mCallback(ctx->mArgument);
    ctx->mIsRunning = false;

    return (THREAD_RETURN)(ctx->mReturned ? -1 : 0);
}
/*--------------------------------------------------------------*/

cf::task::mutex::mutex()
    throw (cf::exception)
    : mIsLocked(false)
{
    mutex_t * inst = NULL;

    try
    {
        inst = reinterpret_cast<mutex_t *>(cf::memory::alloc(sizeof(mutex_t)));

#ifdef _ON_WINDOWS
        InitializeCriticalSection(inst);
#else
        if (pthread_mutex_init(inst, NULL))
            THROW_EXCEPTION("cannot create mutex("
                            << errno << ":" << strerror(errno) << ")");
#endif

        mMutex = inst;
    }
    catch (cf::exception &e)
    {
        cf::memory::free(mMutex);
        FORWARD_EXCEPTION(e);
    }
}

cf::task::mutex::~mutex()
{
    mutex_t * inst = reinterpret_cast<mutex_t *>(mMutex);

#ifdef _ON_WINDOWS
    DeleteCriticalSection(inst);
#else
    pthread_mutex_destroy(inst);
#endif

    cf::memory::free(mMutex);
}

cf::void_t cf::task::mutex::lock()
    throw (cf::exception)
{
    mutex_t * inst = (mutex_t *)mMutex;

#ifdef _ON_WINDOWS
    EnterCriticalSection(inst);
#else
    cf::int32_t result = pthread_mutex_lock(inst);
    if (result)
        THROW_EXCEPTION("cannot lock {" << result << "}");
#endif

    mIsLocked = true;
}

cf::void_t cf::task::mutex::unlock()
    throw (cf::exception)
{
    mutex_t * inst = reinterpret_cast<mutex_t *>(mMutex);

#ifdef _ON_WINDOWS
    LeaveCriticalSection(inst);
#else
    cf::int32_t result = pthread_mutex_unlock(inst);
    if (result)
        THROW_EXCEPTION("cannot unlock {" << result << "}");
#endif

    mIsLocked = false;
}

cf::bool_t cf::task::mutex::trylock()
    throw (cf::exception)
{
    cf::bool_t getLocking = false;
    mutex_t * inst = reinterpret_cast<mutex_t *>(mMutex);

#ifdef _ON_WINDOWS
    getLocking = TryEnterCriticalSection(inst) ? true : false;
#else
    cf::int32_t result = pthread_mutex_trylock(inst);
    switch (result)
    {
        case 0:     getLocking = true;  break;
        case EBUSY: getLocking = false; break;
        default:
            THROW_EXCEPTION("cannot trylock {" << result << "}");
    }
#endif

    if (getLocking)
        mIsLocked = true;

    return getLocking;
}

cf::bool_t cf::task::mutex::locked() const
{
    return mIsLocked;
}

cf::task::scopedLock::scopedLock(ISynchronizer * inst)
    throw (cf::exception)
    : mSynchronizer(inst)
{
    if (!mSynchronizer)
        THROW_EXCEPTION("invalid synchronizer");

    mSynchronizer->lock();
}

cf::task::scopedLock::~scopedLock()
{
    try
    {
        unlock();
    }
    catch (...)
    {
    }
}

cf::bool_t cf::task::scopedLock::locked() const
{
    return mSynchronizer->locked();
}

cf::void_t cf::task::scopedLock::unlock()
    throw (cf::exception)
{
    mSynchronizer->unlock();
}

cf::task::thread::thread(const ThreadFunction callback)
    throw (cf::exception)
    : mThreadID(NULL)
{
    try
    {
        mCtx.mIsRunning = false;
        mCtx.mCallback = callback;

#ifndef _ON_WINDOWS
        mThreadID = cf::memory::alloc(sizeof(thread_t));
#endif
    }
    catch (cf::exception &e)
    {
        FORWARD_EXCEPTION(e);
    }
}

cf::task::thread::~thread()
{
#ifdef _ON_WINDOWS
    if (!mThreadID)
        return;

    CloseHandle(mThreadID);
#else
    cf::memory::free(mThreadID);
#endif
}

cf::void_t cf::task::thread::start(cf::void_t * arg)
    throw (cf::exception)
{
    try
    {
        if (mCtx.mIsRunning)
            return;

        if (!mMutex.trylock())
            return;

        mCtx.mArgument = arg;

#ifdef _ON_WINDOWS
        mThreadID = CreateThread(NULL, 0, Runner, &mCtx, 0, NULL);
        if (mThreadID == NULL)
            THROW_EXCEPTION("cannot create thread");
#else
        cf::int32_t result = 0;

        pthread_attr_t * attr = NULL;
# if defined(_SOLARIS)
        pthread_attr_t solarisAttr;
        struct sched_param sched;

        attr = &solarisAttr;

        result = pthread_attr_init(attr);
        if (result)
            THROW_EXCEPTION("cannot init. thread-attr");

        result = pthread_attr_setinheritsched(attr, PTHREAD_EXPLICIT_SCHED);
        if (result)
            THROW_EXCEPTION("cannot set thread-inherit-schedule-attr");

        result = pthread_attr_setschedpolicy(attr, SCHED_RR);
        if (result)
            THROW_EXCEPTION("cannot set thread-schedule-policy-attr");

        sched.sched_priority = 1;
        result = pthread_attr_setschedparam(attr, &sched);
        if (result)
            THROW_EXCEPTION("cannot set thread-schedule-param-attr");
# endif // # if defined(_SOLARIS)

        result = pthread_create((thread_t *)mThreadID, attr, Runner, &mCtx);
        if (result)
            THROW_EXCEPTION("cannot create thread");
#endif

        mCtx.mIsRunning = true;

        mMutex.unlock();
    }
    catch (cf::exception &e)
    {
        mMutex.unlock();
        throw e;
    }
}

cf::void_t cf::task::thread::join()
{
#ifdef _ON_WINDOWS
    WaitForSingleObject(mThreadID, INFINITE);
#else
    cf::char_t status[16] = {0x00,};
    pthread_join(*((thread_t *)mThreadID), (cf::void_t **)status);
#endif
}

cf::bool_t cf::task::thread::isRunning() const
{
    return mCtx.mIsRunning;
}

cf::uint32_t cf::task::thread::id()
{
#ifdef _ON_WINDOWS
    DWORD tid = GetCurrentThreadId();
#else
    pthread_t tid = pthread_self();
#endif

    return static_cast<cf::uint32_t>(tid);
}

cf::void_t cf::task::thread::sleep(cf::int32_t milliseconds)
{
#ifdef _ON_WINDOWS
    Sleep(static_cast<DWORD>(milliseconds));
#else
    usleep(milliseconds * 1000);
#endif
}

cf::uint32_t cf::task::process::id()
{
#ifdef _ON_WINDOWS
    DWORD pid = GetCurrentProcessId();
#else
    pid_t pid = getpid();
#endif

    return static_cast<cf::uint32_t>(pid);
}