/************************************************************************
 *
 * thread.cpp - definitions of testsuite thread helpers
 *
 * $Id$
 *
 ************************************************************************
 *
 * Licensed to the Apache Software  Foundation (ASF) under one or more
 * contributor  license agreements.  See  the NOTICE  file distributed
 * with  this  work  for  additional information  regarding  copyright
 * ownership.   The ASF  licenses this  file to  you under  the Apache
 * License, Version  2.0 (the  "License"); you may  not use  this file
 * except in  compliance with the License.   You may obtain  a copy of
 * the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the  License is distributed on an  "AS IS" BASIS,
 * WITHOUT  WARRANTIES OR CONDITIONS  OF ANY  KIND, either  express or
 * implied.   See  the License  for  the  specific language  governing
 * permissions and limitations under the License.
 *
 * Copyright 2005-2006 Rogue Wave Software.
 * 
 **************************************************************************/

// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC

#include <rw_thread.h>
#include <stddef.h>     // for size_t
#include <string.h>     // for memset()

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

static long maxthreads;


#if defined (_RWSTD_POSIX_THREADS)
#  include <pthread.h>

extern "C" {

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  void* (*thr_proc)(void*),
                  void *thr_arg)
{
#ifdef _RWSTD_OS_SUNOS

    static int concurrency_set;

    if (0 == concurrency_set) {
        pthread_setconcurrency (4);
        concurrency_set = 1;
    }

#endif   // _RWSTD_OS_SUNOS


    rw_thread_t tmpid;

    if (0 == thr_id) {
        thr_id = &tmpid;
    }

    pthread_t tid;

    // set the thread number *before* creating the thread
    // so that it's visible in thr_proc when it starts to
    // run even before pthread_create returns
    thr_id->threadno = maxthreads;

    const int result = pthread_create (&tid, 0, thr_proc, thr_arg);

    if (0 == result) {
        thr_id->id     = (long)tid;
        thr_id->handle = 0;
        ++maxthreads;
    }

    return result;
}


_TEST_EXPORT int
rw_thread_join (rw_thread_t thr_id, void **parg)
{
    const int result = pthread_join ((pthread_t)thr_id.id, parg);

    return result;
}

}   // extern "C"

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

#elif defined (_RWSTD_SOLARIS_THREADS)
#  include <thread.h>

extern "C" {

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  void* (*thr_proc)(void*),
                  void *thr_arg)
{
    static int concurrency_set;

    if (0 == concurrency_set) {
        thr_setconcurrency (4);
        concurrency_set = 1;
    }

    rw_thread_t tmpid;

    if (0 == thr_id) {
        thr_id = &tmpid;
    }

    thread_t tid;

    // set the thread number *before* creating the thread
    // so that it's visible in thr_proc when it starts to
    // run even before thr_create returns
    thr_id->threadno = maxthreads;

    const int result =
        thr_create (0,          // stack_base
                    0,          // stack_size
                    thr_proc,   // start_func
                    thr_arg,    // arg
                    0,          // flags
                    &tid);      // new_thread_ID

    if (0 == result) {
        thr_id->id     = (long)tid;
        thr_id->handle = 0;
        ++maxthreads;
    }

    return result;
}


_TEST_EXPORT int
rw_thread_join (rw_thread_t thr_id, void **parg)
{
    const int result = thr_join ((thread_t)thr_id.id, 0, parg);

    return result;
}

}   // extern "C"

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

#elif defined (_RWSTD_DEC_THREADS)

#  include <setjmp.h>
#  include <cma.h>


extern "C" {

#  ifdef __PURE_CNAME

extern int sigsetjmp (jmp_buf, int);

#  endif


_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  void* (*thr_proc)(void*),
                  void *thr_arg)
{
    rw_thread_t tmpid;

    if (0 == thr_id) {
        thr_id = &tmpid;
    }

    int result = 0;

    cma_t_thread tid;

    // set the thread number *before* creating the thread
    // so that it's visible in thr_proc when it starts to
    // run even before cma_thread_create returns
    thr_id->threadno = maxthreads;

    TRY {
        // cma_thread_create() returns void but throws an exception on error
        cma_thread_create (&tid,        // new_thread
                           0,           // attr
                           thr_proc,    // start_routine
                           &thr_arg);   // arg

        thr_id->id     = tid.field1;
        thr_id->handle = (void*)tid.field2;
        ++maxthreads;
    }
    CATCH_ALL {
        result = -1;
    }
    ENDTRY

    return result;
}


_TEST_EXPORT int
rw_thread_join (rw_thread_t thr_id, void **parg)
{
    int status = 0;

    cma_t_thread tid = {
        thr_id.id, (long)thr_id.handle
    };

    TRY {
        // cma_thread_join() returns void but throws an exception on error
        cma_thread_join (&tid, 0, parg);
    }
    CATCH_ALL {
        status = -1;
    }
    ENDTRY

    return status;
}

}   // extern "C"

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

#elif defined (_WIN32) || defined (_WIN64)
#  include <windows.h>

extern "C" {

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  void* (*thr_proc)(void*),
                  void *thr_arg)
{
    int result = 0;

    rw_thread_t tmpid;

    if (0 == thr_id)
        thr_id = &tmpid;

    DWORD nid;   // numerical id

    typedef DWORD ThreadProc (LPVOID);

    LPTHREAD_START_ROUTINE win32_thr_proc =
        _RWSTD_REINTERPRET_CAST (LPTHREAD_START_ROUTINE, thr_proc);

    // set the thread number *before* creating the thread
    // so that it's visible in thr_proc when it starts to
    // run even before CreateThread returns
    thr_id->threadno = maxthreads;

    const HANDLE hthread =
        CreateThread (0,                // lpThreadAttributes
                      0,                // dwStackSize
                      win32_thr_proc,   // lpStartAddress
                      thr_arg,          // lpParameter
                      0,                // dwCreationFlags
                      &nid);            // lpThreadId

    if (INVALID_HANDLE_VALUE == hthread) {
        thr_id->id     = -1;
        thr_id->handle = 0;
        result         = -1;
    }
    else {
        thr_id->id     = nid;
        thr_id->handle = hthread;
        ++maxthreads;
    }

    return result;
}


_TEST_EXPORT int
rw_thread_join (rw_thread_t thr_id, void **parg)
{
    int result = 0;

    const DWORD retcode = WaitForSingleObject (thr_id.handle, INFINITE);

    if (WAIT_OBJECT_0 == retcode) {
        if (parg) {
            DWORD exit_code;

            if (GetExitCodeThread (thr_id.handle, &exit_code))
                *parg = (void*)exit_code;
            else
                result = -1;
        }
    }
    else {
        result = -1;
    }

    return result;
}

}   // extern "C"

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

#else   // unknown/missing threads environment

#  include <errno.h>

#  ifndef ENOTSUP
#    if defined (_RWSTD_OS_AIX)
#      define ENOTSUP    124
#    elif defined (_RWSTD_OS_HP_UX)
#      define ENOTSUP    252
#    elif defined (_RWSTD_OS_IRIX64)
#      define ENOTSUP   1008
#    elif defined (_RWSTD_OS_LINUX)
#      define ENOTSUP    524
#    elif defined (_RWSTD_OS_OSF1)
#      define ENOTSUP     99
#    elif defined (_RWSTD_OS_SUNOS)
#      define ENOTSUP     48
#    elif defined (_WIN32) || defined (_WIN64)
#      define ENOTSUP ENOSYS
#    else
#      define ENOTSUP   9999
#    endif
#  endif   // ENOTSUP

extern "C" {

_TEST_EXPORT int
rw_thread_create (rw_thread_t*,
                  rw_thread_attr_t*,
                  void* (*)(void*),
                  void*)
{
    _RWSTD_UNUSED (maxthreads);

    return ENOTSUP;
}


_TEST_EXPORT int
rw_thread_join (rw_thread_t, void**)
{
    return ENOTSUP;
}

}   // extern "C"

#endif   // threads environment


extern "C" {


_TEST_EXPORT int
rw_thread_pool (rw_thread_t *thr_id, size_t nthrs,
                rw_thread_attr_t*,
                void* (*thr_proc)(void*),
                void **thr_arg)
{
    // small buffer for thread ids when invoked with (thr_id == 0)
    rw_thread_t id_buf [16];

    const bool join = 0 == thr_id;

#ifndef _RWSTD_REENTRANT

    // when not reentrant/thread safe emulate the creation
    // of a single thread and then waiting for it to finish
    // by simply calling the thread procedure

    if (1 == nthrs && join) {

        if (0 == thr_id) {
            thr_id = id_buf;
            memset (thr_id, 0, sizeof *thr_id);
        }

        // when the thr_arg pointer is 0 pass the address
        // of each thread's id as the argument to thr_proc
        void* const arg = thr_arg ? thr_arg [0] : (void*)(thr_id);

        void* const thr_result = thr_proc (arg);

        if (thr_arg)
            thr_arg [0] = thr_result;

        return 0;
    }

#endif   // !_RWSTD_REENTRANT

    bool delete_ids = false;

    if (0 == thr_id) {
        // save thread idsso that they (and no other threads)
        // can be joined later
        if (sizeof id_buf / sizeof *id_buf < nthrs) {
            delete_ids = true;
            thr_id     = new rw_thread_t [nthrs];
        }
        else
            thr_id = id_buf;
    }

    // create a pool of threads storing their id's
    // in consecutive elements of the thr_id array
    for (size_t i = 0; i != nthrs; ++i) {

        // when the thr_arg pointer is 0 pass the address
        // of each thread's id as the argument to thr_proc
        void* const next_arg = thr_arg ? thr_arg [i] : (void*)(thr_id + i);

        if (rw_thread_create (thr_id + i, 0, thr_proc, next_arg)) {
            if (delete_ids)
                delete[] thr_id;

            return int (i + 1);
        }
    }

    // invoking the function with a 0 thr_id pointer
    // is a request to join all threads in the pool
    if (join) {
        for (size_t i = 0; i != nthrs; ++i) {

            // avoid advancing through the thr_arg array
            // when it's 0 (and have rw_thread_join() simply
            // ignore the thread's return value)
            void** next_arg = thr_arg ? thr_arg + i : 0;

            rw_thread_join (thr_id [i], next_arg);
        }

        if (delete_ids)
            delete[] thr_id;
    }

    return 0;
}

}   // extern "C"