/************************************************************************
 *
 * 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-2007 Rogue Wave Software, Inc.
 * 
 **************************************************************************/

// expand _TEST_EXPORT macros
#define _RWSTD_TEST_SRC

#include <rw_thread.h>
#include <rw_alarm.h>   // for rw_alarm()

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

#ifndef _WIN32
#  include <stdio.h>      // for FILE, fscanf(), popen()
#  include <unistd.h>     // for sysconf(), _SC_NPROCESSORS_{CONF,ONLN}
#else
#  include <windows.h>    // for GetSystemInfo()
#endif   // _WIN32

#ifndef _RWSTD_NO_PURE_C_HEADERS

extern "C" {
FILE* popen (const char*, const char*);
}   // extern "C"

#endif   // _RWSTD_NO_PURE_C_HEADERS

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

static long maxthreads;

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

static volatile int
_rw_timeout_expired = 0;

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

_TEST_EXPORT int
rw_thread_pool_timeout_expired ()
{
    return _rw_timeout_expired != 0;
}

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

extern "C" {

static void
_rw_timeout_handler (int)
{
    _rw_timeout_expired = 1;
}

}    // extern "C"

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


#if defined (_RWSTD_POSIX_THREADS)

#  ifdef _RWSTD_EDG_ECCP
     // disable error #450-D: the type "long long" is nonstandard
     // issued for uses of the type in Linux system headers (e.g.,
     // pthreadtypes.h)
#    pragma diag_suppress 450
#  endif   // vanilla EDG eccp demo

#  include <pthread.h>

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  rw_thread_proc *thr_proc,
                  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;
}

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

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

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  rw_thread_proc *thr_proc,
                  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;
}

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

#elif defined (_RWSTD_DEC_THREADS)

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

_TEST_EXPORT int
rw_thread_create (rw_thread_t *thr_id,
                  rw_thread_attr_t*,
                  rw_thread_proc *thr_proc,
                  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;
}

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

#elif defined (_WIN32) && defined (_MT)
#  ifdef __MINGW32__
#    include <stdint.h>   // for uintptr_t
#  endif
#  include <process.h>    // for _beginthreadex()

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

    rw_thread_t tmpid;

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

    unsigned nid;   // numerical id

    typedef unsigned int (__stdcall *win32_thr_proc_t)(void *);
    win32_thr_proc_t win32_thr_proc =
        _RWSTD_REINTERPRET_CAST (win32_thr_proc_t, 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 uintptr_t hthread =
        _beginthreadex (0,                // lpThreadAttributes
                        0,                // dwStackSize
                        win32_thr_proc,   // lpStartAddress
                        thr_arg,          // lpParameter
                        0,                // dwCreationFlags
                        &nid);            // lpThreadId

    if (!hthread) {
        thr_id->id     = -1;
        thr_id->handle = 0;
        result         = -1;
    }
    else {
        thr_id->id     = nid;
        thr_id->handle = _RWSTD_REINTERPRET_CAST (void*, 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;
}

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

#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)
#      define ENOTSUP ENOSYS
#    else
#      define ENOTSUP   9999
#    endif
#  endif   // ENOTSUP

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

    return ENOTSUP;
}


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

#endif   // threads environment

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

// retrieves the number of processors/cores on the system
_TEST_EXPORT int
rw_get_cpus ()
{
#ifndef _WIN32

    const char* const cmd = {
        // shell command(s) to obtain the number of processors

#  ifdef _RWSTD_OS_AIX
        // AIX: /etc/lsdev -Cc processor | wc -l
        "/etc/lsdev -Cc processor | /usr/bin/wc -l"
#  elif defined (_RWSTD_OS_LINUX)
        // Linux: cat /proc/cpuinfo | grep processor | wc -l
        "cat /proc/cpuinfo "
        "  | grep processor "
        "  | wc -l"
#  elif defined (_RWSTD_OS_FREEBSD)
        // FreeBSD: /sbin/sysctl -n hw.ncpu
        "/sbin/sysctl -n hw.ncpu"
#  elif defined (_RWSTD_OS_HP_UX)
        // HP-UX: /etc/ioscan -k -C processor | grep processor | wc -l
        "/etc/ioscan -k -C processor "
        "  | /usr/bin/grep processor "
        "  | /usr/bin/wc -l"
#  elif defined (_RWSTD_OS_IRIX64)
        // IRIX: hinv | /usr/bin/grep "^[1-9][0-9]* .* Processor"
        "/sbin/hinv "
        "  | /usr/bin/grep \"^[1-9][0-9]* .* Processor\""
#  elif defined (_RWSTD_OS_OSF1)
        // Tru64 UNIX: /usr/sbin/psrinfo | grep online | wc -l
        "/usr/sbin/psrinfo "
        "  | /usr/bin/grep on[-]*line "
        "  | /usr/bin wc -l"
#  elif defined (_RWSTD_OS_SUNOS)
        // Solaris: /usr/bin/mpstat | wc -l
        "/usr/bin/mpstat "
        "  | /usr/bin/grep -v \"^CPU\" "
        "  | /usr/bin/wc -l"
#  else
        0
#  endif

    };

    int ncpus = -1;

#  ifdef _SC_NPROCESSORS_ONLN
    // try to obtain the number of processors that are currently online
    // programmatically and fall back on the shell script above if it
    // fails
    ncpus = int (sysconf (_SC_NPROCESSORS_ONLN));

#  elif defined (_SC_NPROCESSORS_CONF)

    // try to obtain the number of processors the system is configured
    // with (not all of them are necessarily online) programmatically
    // and fall back on the shell script above if it fails
    ncpus = int (sysconf (_SC_NPROCESSORS_CONF));

#  endif   // _SC_NPROCESSORS_CONF

    if (ncpus < 1 && cmd) {
        // if the number of processors couldn't be determined using
        // sysconf() above,  open and read the output of the command
        // from a pipe
        FILE* const fp = popen (cmd, "r");

        if (fp) {
            int tmp = 0;
        
            int n = fscanf (fp, "%d", &tmp);

            if (1 == n)
                ncpus = tmp;

            fclose (fp);
        }
    }

    return ncpus;

#else    // _WIN32

    SYSTEM_INFO info;
    GetSystemInfo (&info);
    return int (info.dwNumberOfProcessors);

#endif   // _WIN32
}

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

_TEST_EXPORT int
rw_thread_pool (rw_thread_t        *thr_id,
                size_t              nthrs,
                rw_thread_attr_t*,
                rw_thread_proc     *thr_proc,
                void*              *thr_arg,
                size_t              timeout)
{
    // apply timeout if one was specified
    if (0 != timeout) {
        _rw_timeout_expired = 0;
        rw_alarm (unsigned (timeout), _rw_timeout_handler);
    }

    // small buffer for thread ids when invoked with (thr_id == 0)
    rw_thread_t id_buf [16];

    const bool join = 0 == thr_id;

#ifdef _RWSTD_REENTRANT

    if (_RWSTD_SIZE_MAX == nthrs) {
        // when the number of threads is -1 use the number
        // of processors plus 1 (in case it's 1 to begin
        // with)

        const int ncpus = rw_get_cpus ();

        if (0 < ncpus)
            nthrs = size_t (ncpus) + 1;
        else
            nthrs = 2;
    }

#else

    // 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;
}