From bcc19981c36eeaec2f4cc08cbf24438f30ceab61 Mon Sep 17 00:00:00 2001 From: Tanguy Pruvot Date: Mon, 25 Aug 2014 23:41:17 +0200 Subject: [PATCH] windows: use a static lib of pthreads 2.9.1 built with nmake clean VC-static --- ccminer.vcxproj | 21 +- compat/pthreads/pthread.h | 1372 ++++++++++++++++++++++++++++ compat/pthreads/sched.h | 183 ++++ compat/pthreads/x64/pthreadVC2.lib | Bin 0 -> 166580 bytes compat/pthreads/x86/pthreadVC2.lib | Bin 0 -> 81328 bytes cpu-miner.c | 13 +- util.c | 4 +- 7 files changed, 1580 insertions(+), 13 deletions(-) create mode 100644 compat/pthreads/pthread.h create mode 100644 compat/pthreads/sched.h create mode 100644 compat/pthreads/x64/pthreadVC2.lib create mode 100644 compat/pthreads/x86/pthreadVC2.lib diff --git a/ccminer.vcxproj b/ccminer.vcxproj index e240816..e47c1a4 100644 --- a/ccminer.vcxproj +++ b/ccminer.vcxproj @@ -89,13 +89,14 @@ Level3 Disabled WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;CURL_STATICLIB;SCRYPT_KECCAK512;SCRYPT_CHACHA;SCRYPT_CHOOSE_COMPILETIME;%(PreprocessorDefinitions) - .;compat;compat\jansson;compat\getopt;..\pthreads\Pre-built.2\include;..\curl-7.29.0\include;..\OpenSSL-Win32\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) + .;compat;compat\jansson;compat\getopt;compat\pthreads;..\curl-7.29.0\include;..\OpenSSL-Win32\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) true Console cudart.lib;cuda.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;pthreadVC2.lib;libcurl.lib;ws2_32.lib;Wldap32.lib;libeay32MTd.lib;ssleay32MTd.lib;%(AdditionalDependencies) - ..\pthreads\Pre-built.2\lib\x86;..\curl-7.29.0\build\lib\Debug;..\OpenSSL-Win32\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + compat\pthreads\x86;..\curl-7.29.0\build\lib\Debug;..\OpenSSL-Win32\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + /NODEFAULTLIB:LIBCMT %(AdditionalOptions) echo copy "$(CudaToolkitBinDir)\cudart32*.dll" "$(OutDir)" @@ -118,13 +119,14 @@ copy "$(CudaToolkitBinDir)\cudart32*.dll" "$(OutDir)" Level3 Disabled WIN32;_DEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;CURL_STATICLIB;SCRYPT_KECCAK512;SCRYPT_CHACHA;SCRYPT_CHOOSE_COMPILETIME;%(PreprocessorDefinitions) - .;compat;compat\jansson;compat\getopt;..\pthreads\Pre-built.2\include;..\curl-7.29.0_x64\include;..\OpenSSL-Win64\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) + .;compat;compat\jansson;compat\getopt;compat\pthreads;..\curl-7.29.0_x64\include;..\OpenSSL-Win64\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) true Console cudart.lib;cuda.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;pthreadVC2.lib;libcurl.lib;ws2_32.lib;Wldap32.lib;libeay32MTd.lib;ssleay32MTd.lib;%(AdditionalDependencies) - ..\pthreads\Pre-built.2\lib\x64;..\curl-7.29.0_x64\build\lib\Debug;..\OpenSSL-Win64\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + compat\pthreads\x64;..\curl-7.29.0_x64\build\lib\Debug;..\OpenSSL-Win64\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + /NODEFAULTLIB:LIBCMT %(AdditionalOptions) echo copy "$(CudaToolkitBinDir)\cudart64*.dll" "$(OutDir)" @@ -151,7 +153,7 @@ copy "$(CudaToolkitBinDir)\cudart64*.dll" "$(OutDir)" true true WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;CURL_STATICLIB;SCRYPT_KECCAK512;SCRYPT_CHACHA;SCRYPT_CHOOSE_COMPILETIME;MAXWELL_OR_FERMI=1;%(PreprocessorDefinitions) - .;compat;compat\jansson;compat\getopt;..\pthreads\Pre-built.2\include;..\curl-7.29.0\include;..\OpenSSL-Win32\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) + .;compat;compat\jansson;compat\getopt;compat\pthreads;..\curl-7.29.0\include;..\OpenSSL-Win32\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) false @@ -159,7 +161,7 @@ copy "$(CudaToolkitBinDir)\cudart64*.dll" "$(OutDir)" true Console cudart.lib;cuda.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;pthreadVC2.lib;libcurl.lib;ws2_32.lib;Wldap32.lib;libeay32MT.lib;ssleay32MT.lib;%(AdditionalDependencies) - ..\pthreads\Pre-built.2\lib\x86;..\curl-7.29.0\build\lib\Release;..\OpenSSL-Win32\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + compat\pthreads\x86;..\curl-7.29.0\build\lib\Release;..\OpenSSL-Win32\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) /NODEFAULTLIB:LIBCMT %(AdditionalOptions) @@ -192,8 +194,8 @@ copy "$(CudaToolkitBinDir)\cudart32*.dll" "$(OutDir)" MaxSpeed true true - WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;CURL_STATICLIB;SCRYPT_KECCAK512;SCRYPT_CHACHA;SCRYPT_CHOOSE_COMPILETIME;%(PreprocessorDefinitions) - .;compat;compat\jansson;compat\getopt;..\pthreads\Pre-built.2\include;..\curl-7.29.0_x64\include;..\OpenSSL-Win64\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) + WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;CURL_STATICLIB;SCRYPT_KECCAK512;SCRYPT_CHACHA;SCRYPT_CHOOSE_COMPILETIME;MAXWELL_OR_FERMI=1;%(PreprocessorDefinitions) + .;compat;compat\jansson;compat\getopt;compat\pthreads;..\curl-7.29.0_x64\include;..\OpenSSL-Win64\include;%(AdditionalIncludeDirectories);$(CudaToolkitIncludeDir) false @@ -201,7 +203,8 @@ copy "$(CudaToolkitBinDir)\cudart32*.dll" "$(OutDir)" true Console cudart.lib;cuda.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;pthreadVC2.lib;libcurl.lib;ws2_32.lib;Wldap32.lib;libeay32MT.lib;ssleay32MT.lib;%(AdditionalDependencies) - ..\pthreads\Pre-built.2\lib\x64;..\curl-7.29.0_x64\build\lib\Release;..\OpenSSL-Win64\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + compat\pthreads\x64;..\curl-7.29.0_x64\build\lib\Release;..\OpenSSL-Win64\lib\VC\static;%(AdditionalLibraryDirectories);$(CudaToolkitLibDir) + /NODEFAULTLIB:LIBCMT %(AdditionalOptions) echo copy "$(CudaToolkitBinDir)\cudart64*.dll" "$(OutDir)" diff --git a/compat/pthreads/pthread.h b/compat/pthreads/pthread.h new file mode 100644 index 0000000..85f9cce --- /dev/null +++ b/compat/pthreads/pthread.h @@ -0,0 +1,1372 @@ +/* This is an implementation of the threads API of POSIX 1003.1-2001. + * + * -------------------------------------------------------------------------- + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright(C) 1998 John E. Bossom + * Copyright(C) 1999,2005 Pthreads-win32 contributors + * + * Contact Email: rpj@callisto.canberra.edu.au + * + * The current list of contributors is contained + * in the file CONTRIBUTORS included with the source + * code distribution. The list can also be seen at the + * following World Wide Web location: + * http://sources.redhat.com/pthreads-win32/contributors.html + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ + +// undef for DLLs +#define PTW32_STATIC_LIB + + +#if !defined( PTHREAD_H ) +#define PTHREAD_H + +/* + * See the README file for an explanation of the pthreads-win32 version + * numbering scheme and how the DLL is named etc. + */ +#define PTW32_VERSION 2,9,1,0 +#define PTW32_VERSION_STRING "2, 9, 1, 0\0" + +/* There are three implementations of cancel cleanup. + * Note that pthread.h is included in both application + * compilation units and also internally for the library. + * The code here and within the library aims to work + * for all reasonable combinations of environments. + * + * The three implementations are: + * + * WIN32 SEH + * C + * C++ + * + * Please note that exiting a push/pop block via + * "return", "exit", "break", or "continue" will + * lead to different behaviour amongst applications + * depending upon whether the library was built + * using SEH, C++, or C. For example, a library built + * with SEH will call the cleanup routine, while both + * C++ and C built versions will not. + */ + +/* + * Define defaults for cleanup code. + * Note: Unless the build explicitly defines one of the following, then + * we default to standard C style cleanup. This style uses setjmp/longjmp + * in the cancelation and thread exit implementations and therefore won't + * do stack unwinding if linked to applications that have it (e.g. + * C++ apps). This is currently consistent with most/all commercial Unix + * POSIX threads implementations. + */ +#if !defined( __CLEANUP_SEH ) && !defined( __CLEANUP_CXX ) && !defined( __CLEANUP_C ) +# define __CLEANUP_C +#endif + +#if defined( __CLEANUP_SEH ) && ( !defined( _MSC_VER ) && !defined(PTW32_RC_MSC)) +#error ERROR [__FILE__, line __LINE__]: SEH is not supported for this compiler. +#endif + +/* + * Stop here if we are being included by the resource compiler. + */ +#if !defined(RC_INVOKED) + +#undef PTW32_LEVEL + +#if defined(_POSIX_SOURCE) +#define PTW32_LEVEL 0 +/* Early POSIX */ +#endif + +#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 +#undef PTW32_LEVEL +#define PTW32_LEVEL 1 +/* Include 1b, 1c and 1d */ +#endif + +#if defined(INCLUDE_NP) +#undef PTW32_LEVEL +#define PTW32_LEVEL 2 +/* Include Non-Portable extensions */ +#endif + +#define PTW32_LEVEL_MAX 3 + +#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_LEVEL) +#define PTW32_LEVEL PTW32_LEVEL_MAX +/* Include everything */ +#endif + +#if defined(_UWIN) +# define HAVE_STRUCT_TIMESPEC 1 +# define HAVE_SIGNAL_H 1 +# undef HAVE_PTW32_CONFIG_H +# pragma comment(lib, "pthread") +#endif + +/* + * ------------------------------------------------------------- + * + * + * Module: pthread.h + * + * Purpose: + * Provides an implementation of PThreads based upon the + * standard: + * + * POSIX 1003.1-2001 + * and + * The Single Unix Specification version 3 + * + * (these two are equivalent) + * + * in order to enhance code portability between Windows, + * various commercial Unix implementations, and Linux. + * + * See the ANNOUNCE file for a full list of conforming + * routines and defined constants, and a list of missing + * routines and constants not defined in this implementation. + * + * Authors: + * There have been many contributors to this library. + * The initial implementation was contributed by + * John Bossom, and several others have provided major + * sections or revisions of parts of the implementation. + * Often significant effort has been contributed to + * find and fix important bugs and other problems to + * improve the reliability of the library, which sometimes + * is not reflected in the amount of code which changed as + * result. + * As much as possible, the contributors are acknowledged + * in the ChangeLog file in the source code distribution + * where their changes are noted in detail. + * + * Contributors are listed in the CONTRIBUTORS file. + * + * As usual, all bouquets go to the contributors, and all + * brickbats go to the project maintainer. + * + * Maintainer: + * The code base for this project is coordinated and + * eventually pre-tested, packaged, and made available by + * + * Ross Johnson + * + * QA Testers: + * Ultimately, the library is tested in the real world by + * a host of competent and demanding scientists and + * engineers who report bugs and/or provide solutions + * which are then fixed or incorporated into subsequent + * versions of the library. Each time a bug is fixed, a + * test case is written to prove the fix and ensure + * that later changes to the code don't reintroduce the + * same error. The number of test cases is slowly growing + * and therefore so is the code reliability. + * + * Compliance: + * See the file ANNOUNCE for the list of implemented + * and not-implemented routines and defined options. + * Of course, these are all defined is this file as well. + * + * Web site: + * The source code and other information about this library + * are available from + * + * http://sources.redhat.com/pthreads-win32/ + * + * ------------------------------------------------------------- + */ + +/* Try to avoid including windows.h */ +#if (defined(__MINGW64__) || defined(__MINGW32__)) && defined(__cplusplus) +#define PTW32_INCLUDE_WINDOWS_H +#endif + +#if defined(PTW32_INCLUDE_WINDOWS_H) +#include +#endif + +#if defined(_MSC_VER) && _MSC_VER < 1300 || defined(__DMC__) +/* + * VC++6.0 or early compiler's header has no DWORD_PTR type. + */ +typedef unsigned long DWORD_PTR; +typedef unsigned long ULONG_PTR; +#endif +/* + * ----------------- + * autoconf switches + * ----------------- + */ + +#if defined(HAVE_PTW32_CONFIG_H) +#include "config.h" +#endif /* HAVE_PTW32_CONFIG_H */ + +#if !defined(NEED_FTIME) +#include +#else /* NEED_FTIME */ +/* use native WIN32 time API */ +#endif /* NEED_FTIME */ + +#if defined(HAVE_SIGNAL_H) +#include +#endif /* HAVE_SIGNAL_H */ + +#include + +/* + * Boolean values to make us independent of system includes. + */ +enum { + PTW32_FALSE = 0, + PTW32_TRUE = (! PTW32_FALSE) +}; + +/* + * This is a duplicate of what is in the autoconf config.h, + * which is only used when building the pthread-win32 libraries. + */ + +#if !defined(PTW32_CONFIG_H) +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(__MINGW64__) +# define HAVE_STRUCT_TIMESPEC +# define HAVE_MODE_T +# elif defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +#if defined(NEED_ERRNO) +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Several systems don't define some error numbers. + */ +#if !defined(ENOTSUP) +# define ENOTSUP 48 /* This is the value in Solaris. */ +#endif + +#if !defined(ETIMEDOUT) +# define ETIMEDOUT 10060 /* Same as WSAETIMEDOUT */ +#endif + +#if !defined(ENOSYS) +# define ENOSYS 140 /* Semi-arbitrary value */ +#endif + +#if !defined(EDEADLK) +# if defined(EDEADLOCK) +# define EDEADLK EDEADLOCK +# else +# define EDEADLK 36 /* This is the value in MSVC. */ +# endif +#endif + +/* POSIX 2008 - related to robust mutexes */ +#if !defined(EOWNERDEAD) +# define EOWNERDEAD 43 +#endif +#if !defined(ENOTRECOVERABLE) +# define ENOTRECOVERABLE 44 +#endif + +#include + +/* + * To avoid including windows.h we define only those things that we + * actually need from it. + */ +#if !defined(PTW32_INCLUDE_WINDOWS_H) +#if !defined(HANDLE) +# define PTW32__HANDLE_DEF +# define HANDLE void * +#endif +#if !defined(DWORD) +# define PTW32__DWORD_DEF +# define DWORD unsigned long +#endif +#endif + +#if !defined(HAVE_STRUCT_TIMESPEC) +#define HAVE_STRUCT_TIMESPEC +#if !defined(_TIMESPEC_DEFINED) +#define _TIMESPEC_DEFINED +struct timespec { + time_t tv_sec; + long tv_nsec; +}; +#endif /* _TIMESPEC_DEFINED */ +#endif /* HAVE_STRUCT_TIMESPEC */ + +#if !defined(SIG_BLOCK) +#define SIG_BLOCK 0 +#endif /* SIG_BLOCK */ + +#if !defined(SIG_UNBLOCK) +#define SIG_UNBLOCK 1 +#endif /* SIG_UNBLOCK */ + +#if !defined(SIG_SETMASK) +#define SIG_SETMASK 2 +#endif /* SIG_SETMASK */ + +#if defined(__cplusplus) +extern "C" +{ +#endif /* __cplusplus */ + +/* + * ------------------------------------------------------------- + * + * POSIX 1003.1-2001 Options + * ========================= + * + * Options are normally set in , which is not provided + * with pthreads-win32. + * + * For conformance with the Single Unix Specification (version 3), all of the + * options below are defined, and have a value of either -1 (not supported) + * or 200112L (supported). + * + * These options can neither be left undefined nor have a value of 0, because + * either indicates that sysconf(), which is not implemented, may be used at + * runtime to check the status of the option. + * + * _POSIX_THREADS (== 200112L) + * If == 200112L, you can use threads + * + * _POSIX_THREAD_ATTR_STACKSIZE (== 200112L) + * If == 200112L, you can control the size of a thread's + * stack + * pthread_attr_getstacksize + * pthread_attr_setstacksize + * + * _POSIX_THREAD_ATTR_STACKADDR (== -1) + * If == 200112L, you can allocate and control a thread's + * stack. If not supported, the following functions + * will return ENOSYS, indicating they are not + * supported: + * pthread_attr_getstackaddr + * pthread_attr_setstackaddr + * + * _POSIX_THREAD_PRIORITY_SCHEDULING (== -1) + * If == 200112L, you can use realtime scheduling. + * This option indicates that the behaviour of some + * implemented functions conforms to the additional TPS + * requirements in the standard. E.g. rwlocks favour + * writers over readers when threads have equal priority. + * + * _POSIX_THREAD_PRIO_INHERIT (== -1) + * If == 200112L, you can create priority inheritance + * mutexes. + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PRIO_PROTECT (== -1) + * If == 200112L, you can create priority ceiling mutexes + * Indicates the availability of: + * pthread_mutex_getprioceiling + * pthread_mutex_setprioceiling + * pthread_mutexattr_getprioceiling + * pthread_mutexattr_getprotocol + + * pthread_mutexattr_setprioceiling + * pthread_mutexattr_setprotocol + + * + * _POSIX_THREAD_PROCESS_SHARED (== -1) + * If set, you can create mutexes and condition + * variables that can be shared with another + * process.If set, indicates the availability + * of: + * pthread_mutexattr_getpshared + * pthread_mutexattr_setpshared + * pthread_condattr_getpshared + * pthread_condattr_setpshared + * + * _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L) + * If == 200112L you can use the special *_r library + * functions that provide thread-safe behaviour + * + * _POSIX_READER_WRITER_LOCKS (== 200112L) + * If == 200112L, you can use read/write locks + * + * _POSIX_SPIN_LOCKS (== 200112L) + * If == 200112L, you can use spin locks + * + * _POSIX_BARRIERS (== 200112L) + * If == 200112L, you can use barriers + * + * + These functions provide both 'inherit' and/or + * 'protect' protocol, based upon these macro + * settings. + * + * ------------------------------------------------------------- + */ + +/* + * POSIX Options + */ +#undef _POSIX_THREADS +#define _POSIX_THREADS 200809L + +#undef _POSIX_READER_WRITER_LOCKS +#define _POSIX_READER_WRITER_LOCKS 200809L + +#undef _POSIX_SPIN_LOCKS +#define _POSIX_SPIN_LOCKS 200809L + +#undef _POSIX_BARRIERS +#define _POSIX_BARRIERS 200809L + +#undef _POSIX_THREAD_SAFE_FUNCTIONS +#define _POSIX_THREAD_SAFE_FUNCTIONS 200809L + +#undef _POSIX_THREAD_ATTR_STACKSIZE +#define _POSIX_THREAD_ATTR_STACKSIZE 200809L + +/* + * The following options are not supported + */ +#undef _POSIX_THREAD_ATTR_STACKADDR +#define _POSIX_THREAD_ATTR_STACKADDR -1 + +#undef _POSIX_THREAD_PRIO_INHERIT +#define _POSIX_THREAD_PRIO_INHERIT -1 + +#undef _POSIX_THREAD_PRIO_PROTECT +#define _POSIX_THREAD_PRIO_PROTECT -1 + +/* TPS is not fully supported. */ +#undef _POSIX_THREAD_PRIORITY_SCHEDULING +#define _POSIX_THREAD_PRIORITY_SCHEDULING -1 + +#undef _POSIX_THREAD_PROCESS_SHARED +#define _POSIX_THREAD_PROCESS_SHARED -1 + + +/* + * POSIX 1003.1-2001 Limits + * =========================== + * + * These limits are normally set in , which is not provided with + * pthreads-win32. + * + * PTHREAD_DESTRUCTOR_ITERATIONS + * Maximum number of attempts to destroy + * a thread's thread-specific data on + * termination (must be at least 4) + * + * PTHREAD_KEYS_MAX + * Maximum number of thread-specific data keys + * available per process (must be at least 128) + * + * PTHREAD_STACK_MIN + * Minimum supported stack size for a thread + * + * PTHREAD_THREADS_MAX + * Maximum number of threads supported per + * process (must be at least 64). + * + * SEM_NSEMS_MAX + * The maximum number of semaphores a process can have. + * (must be at least 256) + * + * SEM_VALUE_MAX + * The maximum value a semaphore can have. + * (must be at least 32767) + * + */ +#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS +#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4 + +#undef PTHREAD_DESTRUCTOR_ITERATIONS +#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS + +#undef _POSIX_THREAD_KEYS_MAX +#define _POSIX_THREAD_KEYS_MAX 128 + +#undef PTHREAD_KEYS_MAX +#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX + +#undef PTHREAD_STACK_MIN +#define PTHREAD_STACK_MIN 0 + +#undef _POSIX_THREAD_THREADS_MAX +#define _POSIX_THREAD_THREADS_MAX 64 + + /* Arbitrary value */ +#undef PTHREAD_THREADS_MAX +#define PTHREAD_THREADS_MAX 2019 + +#undef _POSIX_SEM_NSEMS_MAX +#define _POSIX_SEM_NSEMS_MAX 256 + + /* Arbitrary value */ +#undef SEM_NSEMS_MAX +#define SEM_NSEMS_MAX 1024 + +#undef _POSIX_SEM_VALUE_MAX +#define _POSIX_SEM_VALUE_MAX 32767 + +#undef SEM_VALUE_MAX +#define SEM_VALUE_MAX INT_MAX + + +#if defined(__GNUC__) && !defined(__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the library, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the library, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#if !defined(PTW32_STATIC_LIB) +# if defined(PTW32_BUILD) +# define PTW32_DLLPORT __declspec (dllexport) +# else +# define PTW32_DLLPORT __declspec (dllimport) +# endif +#else +# define PTW32_DLLPORT +#endif + +/* + * The Open Watcom C/C++ compiler uses a non-standard calling convention + * that passes function args in registers unless __cdecl is explicitly specified + * in exposed function prototypes. + * + * We force all calls to cdecl even though this could slow Watcom code down + * slightly. If you know that the Watcom compiler will be used to build both + * the DLL and application, then you can probably define this as a null string. + * Remember that pthread.h (this file) is used for both the DLL and application builds. + */ +#define PTW32_CDECL __cdecl + +#if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX +# include +#else +/* + * Generic handle type - intended to extend uniqueness beyond + * that available with a simple pointer. It should scale for either + * IA-32 or IA-64. + */ +typedef struct { + void * p; /* Pointer to actual object */ + unsigned int x; /* Extra information - reuse count etc */ +} ptw32_handle_t; + +typedef ptw32_handle_t pthread_t; +typedef struct pthread_attr_t_ * pthread_attr_t; +typedef struct pthread_once_t_ pthread_once_t; +typedef struct pthread_key_t_ * pthread_key_t; +typedef struct pthread_mutex_t_ * pthread_mutex_t; +typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t; +typedef struct pthread_cond_t_ * pthread_cond_t; +typedef struct pthread_condattr_t_ * pthread_condattr_t; +#endif +typedef struct pthread_rwlock_t_ * pthread_rwlock_t; +typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t; +typedef struct pthread_spinlock_t_ * pthread_spinlock_t; +typedef struct pthread_barrier_t_ * pthread_barrier_t; +typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t; + +/* + * ==================== + * ==================== + * POSIX Threads + * ==================== + * ==================== + */ + +enum { +/* + * pthread_attr_{get,set}detachstate + */ + PTHREAD_CREATE_JOINABLE = 0, /* Default */ + PTHREAD_CREATE_DETACHED = 1, + +/* + * pthread_attr_{get,set}inheritsched + */ + PTHREAD_INHERIT_SCHED = 0, + PTHREAD_EXPLICIT_SCHED = 1, /* Default */ + +/* + * pthread_{get,set}scope + */ + PTHREAD_SCOPE_PROCESS = 0, + PTHREAD_SCOPE_SYSTEM = 1, /* Default */ + +/* + * pthread_setcancelstate paramters + */ + PTHREAD_CANCEL_ENABLE = 0, /* Default */ + PTHREAD_CANCEL_DISABLE = 1, + +/* + * pthread_setcanceltype parameters + */ + PTHREAD_CANCEL_ASYNCHRONOUS = 0, + PTHREAD_CANCEL_DEFERRED = 1, /* Default */ + +/* + * pthread_mutexattr_{get,set}pshared + * pthread_condattr_{get,set}pshared + */ + PTHREAD_PROCESS_PRIVATE = 0, + PTHREAD_PROCESS_SHARED = 1, + +/* + * pthread_mutexattr_{get,set}robust + */ + PTHREAD_MUTEX_STALLED = 0, /* Default */ + PTHREAD_MUTEX_ROBUST = 1, + +/* + * pthread_barrier_wait + */ + PTHREAD_BARRIER_SERIAL_THREAD = -1 +}; + +/* + * ==================== + * ==================== + * Cancelation + * ==================== + * ==================== + */ +#define PTHREAD_CANCELED ((void *)(size_t) -1) + + +/* + * ==================== + * ==================== + * Once Key + * ==================== + * ==================== + */ +#define PTHREAD_ONCE_INIT { PTW32_FALSE, 0, 0, 0} + +struct pthread_once_t_ +{ + int done; /* indicates if user function has been executed */ + void * lock; + int reserved1; + int reserved2; +}; + + +/* + * ==================== + * ==================== + * Object initialisers + * ==================== + * ==================== + */ +#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -1) +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -2) +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t)(size_t) -3) + +/* + * Compatibility with LinuxThreads + */ +#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER +#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER + +#define PTHREAD_COND_INITIALIZER ((pthread_cond_t)(size_t) -1) + +#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t)(size_t) -1) + +#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t)(size_t) -1) + + +/* + * Mutex types. + */ +enum +{ + /* Compatibility with LinuxThreads */ + PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP, + /* For compatibility with POSIX */ + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL +}; + + +typedef struct ptw32_cleanup_t ptw32_cleanup_t; + +#if defined(_MSC_VER) +/* Disable MSVC 'anachronism used' warning */ +#pragma warning( disable : 4229 ) +#endif + +typedef void (* PTW32_CDECL ptw32_cleanup_callback_t)(void *); + +#if defined(_MSC_VER) +#pragma warning( default : 4229 ) +#endif + +struct ptw32_cleanup_t +{ + ptw32_cleanup_callback_t routine; + void *arg; + struct ptw32_cleanup_t *prev; +}; + +#if defined(__CLEANUP_SEH) + /* + * WIN32 SEH version of cancel cleanup. + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + ptw32_cleanup_t _cleanup; \ + \ + _cleanup.routine = (ptw32_cleanup_callback_t)(_rout); \ + _cleanup.arg = (_arg); \ + __try \ + { \ + +#define pthread_cleanup_pop( _execute ) \ + } \ + __finally \ + { \ + if( _execute || AbnormalTermination()) \ + { \ + (*(_cleanup.routine))( _cleanup.arg ); \ + } \ + } \ + } + +#else /* __CLEANUP_SEH */ + +#if defined(__CLEANUP_C) + + /* + * C implementation of PThreads cancel cleanup + */ + +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + ptw32_cleanup_t _cleanup; \ + \ + ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \ + +#define pthread_cleanup_pop( _execute ) \ + (void) ptw32_pop_cleanup( _execute ); \ + } + +#else /* __CLEANUP_C */ + +#if defined(__CLEANUP_CXX) + + /* + * C++ version of cancel cleanup. + * - John E. Bossom. + */ + + class PThreadCleanup { + /* + * PThreadCleanup + * + * Purpose + * This class is a C++ helper class that is + * used to implement pthread_cleanup_push/ + * pthread_cleanup_pop. + * The destructor of this class automatically + * pops the pushed cleanup routine regardless + * of how the code exits the scope + * (i.e. such as by an exception) + */ + ptw32_cleanup_callback_t cleanUpRout; + void * obj; + int executeIt; + + public: + PThreadCleanup() : + cleanUpRout( 0 ), + obj( 0 ), + executeIt( 0 ) + /* + * No cleanup performed + */ + { + } + + PThreadCleanup( + ptw32_cleanup_callback_t routine, + void * arg ) : + cleanUpRout( routine ), + obj( arg ), + executeIt( 1 ) + /* + * Registers a cleanup routine for 'arg' + */ + { + } + + ~PThreadCleanup() + { + if ( executeIt && ((void *) cleanUpRout != (void *) 0) ) + { + (void) (*cleanUpRout)( obj ); + } + } + + void execute( int exec ) + { + executeIt = exec; + } + }; + + /* + * C++ implementation of PThreads cancel cleanup; + * This implementation takes advantage of a helper + * class who's destructor automatically calls the + * cleanup routine if we exit our scope weirdly + */ +#define pthread_cleanup_push( _rout, _arg ) \ + { \ + PThreadCleanup cleanup((ptw32_cleanup_callback_t)(_rout), \ + (void *) (_arg) ); + +#define pthread_cleanup_pop( _execute ) \ + cleanup.execute( _execute ); \ + } + +#else + +#error ERROR [__FILE__, line __LINE__]: Cleanup type undefined. + +#endif /* __CLEANUP_CXX */ + +#endif /* __CLEANUP_C */ + +#endif /* __CLEANUP_SEH */ + +/* + * =============== + * =============== + * Methods + * =============== + * =============== + */ + +/* + * PThread Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_attr_init (pthread_attr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr, + int *detachstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr, + void **stackaddr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr, + size_t * stacksize); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr, + int detachstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr, + void *stackaddr); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr, + size_t stacksize); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr, + struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr, + const struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *, + int); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy (const pthread_attr_t *, + int *); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr, + int inheritsched); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(const pthread_attr_t * attr, + int * inheritsched); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope (pthread_attr_t *, + int); + +PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *, + int *); + +/* + * PThread Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_create (pthread_t * tid, + const pthread_attr_t * attr, + void *(PTW32_CDECL *start) (void *), + void *arg); + +PTW32_DLLPORT int PTW32_CDECL pthread_detach (pthread_t tid); + +PTW32_DLLPORT int PTW32_CDECL pthread_equal (pthread_t t1, + pthread_t t2); + +PTW32_DLLPORT void PTW32_CDECL pthread_exit (void *value_ptr); + +PTW32_DLLPORT int PTW32_CDECL pthread_join (pthread_t thread, + void **value_ptr); + +PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self (void); + +PTW32_DLLPORT int PTW32_CDECL pthread_cancel (pthread_t thread); + +PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate (int state, + int *oldstate); + +PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype (int type, + int *oldtype); + +PTW32_DLLPORT void PTW32_CDECL pthread_testcancel (void); + +PTW32_DLLPORT int PTW32_CDECL pthread_once (pthread_once_t * once_control, + void (PTW32_CDECL *init_routine) (void)); + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX +PTW32_DLLPORT ptw32_cleanup_t * PTW32_CDECL ptw32_pop_cleanup (int execute); + +PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup (ptw32_cleanup_t * cleanup, + ptw32_cleanup_callback_t routine, + void *arg); +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Thread Specific Data Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_key_create (pthread_key_t * key, + void (PTW32_CDECL *destructor) (void *)); + +PTW32_DLLPORT int PTW32_CDECL pthread_key_delete (pthread_key_t key); + +PTW32_DLLPORT int PTW32_CDECL pthread_setspecific (pthread_key_t key, + const void *value); + +PTW32_DLLPORT void * PTW32_CDECL pthread_getspecific (pthread_key_t key); + + +/* + * Mutex Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t + * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr, + int pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype (const pthread_mutexattr_t * attr, int *kind); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setrobust( + pthread_mutexattr_t *attr, + int robust); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getrobust( + const pthread_mutexattr_t * attr, + int * robust); + +/* + * Barrier Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t + * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr, + int pshared); + +/* + * Mutex Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex, + const pthread_mutexattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t * mutex, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_mutex_consistent (pthread_mutex_t * mutex); + +/* + * Spinlock Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock); + +/* + * Barrier Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier, + const pthread_barrierattr_t * attr, + unsigned int count); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier); + +PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier); + +/* + * Condition Variable Attribute Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr, + int pshared); + +/* + * Condition Variable Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_cond_init (pthread_cond_t * cond, + const pthread_condattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond, + pthread_mutex_t * mutex); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond, + pthread_mutex_t * mutex, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond); + +PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond); + +/* + * Scheduling + */ +PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam (pthread_t thread, + int policy, + const struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam (pthread_t thread, + int *policy, + struct sched_param *param); + +PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency (int); + +PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency (void); + +/* + * Read-Write Lock Functions + */ +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock, + const pthread_rwlockattr_t *attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock, + const struct timespec *abstime); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr, + int *pshared); + +PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr, + int pshared); + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 + +/* + * Signal Functions. Should be defined in but MSVC and MinGW32 + * already have signal.h that don't define these. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig); + +/* + * Non-portable functions + */ + +/* + * Compatibility with Linux. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr, + int kind); +PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr, + int *kind); + +/* + * Possibly supported by other POSIX threads implementations + */ +PTW32_DLLPORT int PTW32_CDECL pthread_delay_np (struct timespec * interval); +PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void); +PTW32_DLLPORT unsigned __int64 PTW32_CDECL pthread_getunique_np(pthread_t thread); + +/* + * Useful if an application wants to statically link + * the lib rather than load the DLL at run-time. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void); +PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void); + +/* + * Features that are auto-detected at load/run time. + */ +PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int); +enum ptw32_features { + PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001, /* System provides it. */ + PTW32_ALERTABLE_ASYNC_CANCEL = 0x0002 /* Can cancel blocked threads. */ +}; + +/* + * Register a system time change with the library. + * Causes the library to perform various functions + * in response to the change. Should be called whenever + * the application's top level window receives a + * WM_TIMECHANGE message. It can be passed directly to + * pthread_create() as a new thread if desired. + */ +PTW32_DLLPORT void * PTW32_CDECL pthread_timechange_handler_np(void *); + +#endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */ + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX + +/* + * Returns the Win32 HANDLE for the POSIX thread. + */ +PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread); +/* + * Returns the win32 thread ID for POSIX thread. + */ +PTW32_DLLPORT DWORD PTW32_CDECL pthread_getw32threadid_np (pthread_t thread); + + +/* + * Protected Methods + * + * This function blocks until the given WIN32 handle + * is signaled or pthread_cancel had been called. + * This function allows the caller to hook into the + * PThreads cancel mechanism. It is implemented using + * + * WaitForMultipleObjects + * + * on 'waitHandle' and a manually reset WIN32 Event + * used to implement pthread_cancel. The 'timeout' + * argument to TimedWait is simply passed to + * WaitForMultipleObjects. + */ +PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait (HANDLE waitHandle); +PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait (HANDLE waitHandle, + DWORD timeout); + +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +/* + * Thread-Safe C Runtime Library Mappings. + */ +#if !defined(_UWIN) +# if defined(NEED_ERRNO) + PTW32_DLLPORT int * PTW32_CDECL _errno( void ); +# else +# if !defined(errno) +# if (defined(_MT) || defined(_DLL)) + __declspec(dllimport) extern int * __cdecl _errno(void); +# define errno (*_errno()) +# endif +# endif +# endif +#endif + +/* + * Some compiler environments don't define some things. + */ +#if defined(__BORLANDC__) +# define _ftime ftime +# define _timeb timeb +#endif + +#if defined(__cplusplus) + +/* + * Internal exceptions + */ +class ptw32_exception {}; +class ptw32_exception_cancel : public ptw32_exception {}; +class ptw32_exception_exit : public ptw32_exception {}; + +#endif + +#if PTW32_LEVEL >= PTW32_LEVEL_MAX + +/* FIXME: This is only required if the library was built using SEH */ +/* + * Get internal SEH tag + */ +PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void); + +#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */ + +#if !defined(PTW32_BUILD) + +#if defined(__CLEANUP_SEH) + +/* + * Redefine the SEH __except keyword to ensure that applications + * propagate our internal exceptions up to the library's internal handlers. + */ +#define __except( E ) \ + __except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) \ + ? EXCEPTION_CONTINUE_SEARCH : ( E ) ) + +#endif /* __CLEANUP_SEH */ + +#if defined(__CLEANUP_CXX) + +/* + * Redefine the C++ catch keyword to ensure that applications + * propagate our internal exceptions up to the library's internal handlers. + */ +#if defined(_MSC_VER) + /* + * WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll' + * if you want Pthread-Win32 cancelation and pthread_exit to work. + */ + +#if !defined(PtW32NoCatchWarn) + +#pragma message("Specify \"/DPtW32NoCatchWarn\" compiler flag to skip this message.") +#pragma message("------------------------------------------------------------------") +#pragma message("When compiling applications with MSVC++ and C++ exception handling:") +#pragma message(" Replace any 'catch( ... )' in routines called from POSIX threads") +#pragma message(" with 'PtW32CatchAll' or 'CATCHALL' if you want POSIX thread") +#pragma message(" cancelation and pthread_exit to work. For example:") +#pragma message("") +#pragma message(" #if defined(PtW32CatchAll)") +#pragma message(" PtW32CatchAll") +#pragma message(" #else") +#pragma message(" catch(...)") +#pragma message(" #endif") +#pragma message(" {") +#pragma message(" /* Catchall block processing */") +#pragma message(" }") +#pragma message("------------------------------------------------------------------") + +#endif + +#define PtW32CatchAll \ + catch( ptw32_exception & ) { throw; } \ + catch( ... ) + +#else /* _MSC_VER */ + +#define catch( E ) \ + catch( ptw32_exception & ) { throw; } \ + catch( E ) + +#endif /* _MSC_VER */ + +#endif /* __CLEANUP_CXX */ + +#endif /* ! PTW32_BUILD */ + +#if defined(__cplusplus) +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#if defined(PTW32__HANDLE_DEF) +# undef HANDLE +#endif +#if defined(PTW32__DWORD_DEF) +# undef DWORD +#endif + +#undef PTW32_LEVEL +#undef PTW32_LEVEL_MAX + +#endif /* ! RC_INVOKED */ + +#endif /* PTHREAD_H */ diff --git a/compat/pthreads/sched.h b/compat/pthreads/sched.h new file mode 100644 index 0000000..f36a97a --- /dev/null +++ b/compat/pthreads/sched.h @@ -0,0 +1,183 @@ +/* + * Module: sched.h + * + * Purpose: + * Provides an implementation of POSIX realtime extensions + * as defined in + * + * POSIX 1003.1b-1993 (POSIX.1b) + * + * -------------------------------------------------------------------------- + * + * Pthreads-win32 - POSIX Threads Library for Win32 + * Copyright(C) 1998 John E. Bossom + * Copyright(C) 1999,2005 Pthreads-win32 contributors + * + * Contact Email: rpj@callisto.canberra.edu.au + * + * The current list of contributors is contained + * in the file CONTRIBUTORS included with the source + * code distribution. The list can also be seen at the + * following World Wide Web location: + * http://sources.redhat.com/pthreads-win32/contributors.html + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library in the file COPYING.LIB; + * if not, write to the Free Software Foundation, Inc., + * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + */ +#if !defined(_SCHED_H) +#define _SCHED_H + +#undef PTW32_SCHED_LEVEL + +#if defined(_POSIX_SOURCE) +#define PTW32_SCHED_LEVEL 0 +/* Early POSIX */ +#endif + +#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309 +#undef PTW32_SCHED_LEVEL +#define PTW32_SCHED_LEVEL 1 +/* Include 1b, 1c and 1d */ +#endif + +#if defined(INCLUDE_NP) +#undef PTW32_SCHED_LEVEL +#define PTW32_SCHED_LEVEL 2 +/* Include Non-Portable extensions */ +#endif + +#define PTW32_SCHED_LEVEL_MAX 3 + +#if ( defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 200112 ) || !defined(PTW32_SCHED_LEVEL) +#define PTW32_SCHED_LEVEL PTW32_SCHED_LEVEL_MAX +/* Include everything */ +#endif + + +#if defined(__GNUC__) && !defined(__declspec) +# error Please upgrade your GNU compiler to one that supports __declspec. +#endif + +/* + * When building the library, you should define PTW32_BUILD so that + * the variables/functions are exported correctly. When using the library, + * do NOT define PTW32_BUILD, and then the variables/functions will + * be imported correctly. + */ +#if !defined(PTW32_STATIC_LIB) +# if defined(PTW32_BUILD) +# define PTW32_DLLPORT __declspec (dllexport) +# else +# define PTW32_DLLPORT __declspec (dllimport) +# endif +#else +# define PTW32_DLLPORT +#endif + +/* + * This is a duplicate of what is in the autoconf config.h, + * which is only used when building the pthread-win32 libraries. + */ + +#if !defined(PTW32_CONFIG_H) +# if defined(WINCE) +# define NEED_ERRNO +# define NEED_SEM +# endif +# if defined(__MINGW64__) +# define HAVE_STRUCT_TIMESPEC +# define HAVE_MODE_T +# elif defined(_UWIN) || defined(__MINGW32__) +# define HAVE_MODE_T +# endif +#endif + +/* + * + */ + +#if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX +#if defined(NEED_ERRNO) +#include "need_errno.h" +#else +#include +#endif +#endif /* PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX */ + +#if (defined(__MINGW64__) || defined(__MINGW32__)) || defined(_UWIN) +# if PTW32_SCHED_LEVEL >= PTW32_SCHED_LEVEL_MAX +/* For pid_t */ +# include +/* Required by Unix 98 */ +# include +# else + typedef int pid_t; +# endif +#else + typedef int pid_t; +#endif + +/* Thread scheduling policies */ + +enum { + SCHED_OTHER = 0, + SCHED_FIFO, + SCHED_RR, + SCHED_MIN = SCHED_OTHER, + SCHED_MAX = SCHED_RR +}; + +struct sched_param { + int sched_priority; +}; + +#if defined(__cplusplus) +extern "C" +{ +#endif /* __cplusplus */ + +PTW32_DLLPORT int __cdecl sched_yield (void); + +PTW32_DLLPORT int __cdecl sched_get_priority_min (int policy); + +PTW32_DLLPORT int __cdecl sched_get_priority_max (int policy); + +PTW32_DLLPORT int __cdecl sched_setscheduler (pid_t pid, int policy); + +PTW32_DLLPORT int __cdecl sched_getscheduler (pid_t pid); + +/* + * Note that this macro returns ENOTSUP rather than + * ENOSYS as might be expected. However, returning ENOSYS + * should mean that sched_get_priority_{min,max} are + * not implemented as well as sched_rr_get_interval. + * This is not the case, since we just don't support + * round-robin scheduling. Therefore I have chosen to + * return the same value as sched_setscheduler when + * SCHED_RR is passed to it. + */ +#define sched_rr_get_interval(_pid, _interval) \ + ( errno = ENOTSUP, (int) -1 ) + + +#if defined(__cplusplus) +} /* End of extern "C" */ +#endif /* __cplusplus */ + +#undef PTW32_SCHED_LEVEL +#undef PTW32_SCHED_LEVEL_MAX + +#endif /* !_SCHED_H */ + diff --git a/compat/pthreads/x64/pthreadVC2.lib b/compat/pthreads/x64/pthreadVC2.lib new file mode 100644 index 0000000000000000000000000000000000000000..3e26e4a066c3eeca1a1de8a78bf9c089b1750407 GIT binary patch literal 166580 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%0AQh+iyo9R|j%2KZ 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 literal 0 HcmV?d00001 diff --git a/cpu-miner.c b/cpu-miner.c index 9eb0a58..2b3c218 100644 --- a/cpu-miner.c +++ b/cpu-miner.c @@ -1210,9 +1210,19 @@ out: return NULL; } +#define PROGRAM_VERSION "1.3" static void show_version_and_exit(void) { - printf("%s\n%s\n", PACKAGE_STRING, curl_version()); + printf("%s v%s\n" +#ifdef WIN32 + "pthreads static %s\n" +#endif + "%s\n", + PACKAGE_STRING, PROGRAM_VERSION, +#ifdef WIN32 + PTW32_VERSION_STRING, +#endif + curl_version()); exit(0); } @@ -1560,7 +1570,6 @@ BOOL WINAPI ConsoleHandler(DWORD dwType) } #endif -#define PROGRAM_VERSION "1.3" int main(int argc, char *argv[]) { struct thr_info *thr; diff --git a/util.c b/util.c index 5cb9bd7..300060a 100644 --- a/util.c +++ b/util.c @@ -125,8 +125,8 @@ void applog(int prio, const char *fmt, ...) if (!use_colors) color = ""; - len = 40 + strlen(fmt) + 2; - f = alloca(len); + len = 40 + (int) strlen(fmt) + 2; + f = (char*) alloca(len); sprintf(f, "[%d-%02d-%02d %02d:%02d:%02d]%s %s%s\n", tm.tm_year + 1900, tm.tm_mon + 1,