ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

3rdparty: Remove pthreads4w

This commit is contained in:
Stenzek 2022-12-24 14:54:28 +10:00 committed by refractionpcsx2
parent 70cd26ce6a
commit 8696812d23
403 changed files with 0 additions and 66935 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

483
3rdparty/pthreads4w/ANNOUNCE vendored
View File

@ -1,483 +0,0 @@
PTHREADS-WIN32 RELEASE 2.9.0 (2012-05-25)
-----------------------------------------
Web Site: http://sourceware.org/pthreads-win32/
FTP Site: ftp://sourceware.org/pub/pthreads-win32
Maintainer: Ross Johnson <ross.johnson@loungebythelake.net>
We are pleased to announce the availability of a new release of
Pthreads-win32, an Open Source Software implementation of the
Threads component of the POSIX 1003.1 2001 Standard for Microsoft's
Win32 environment. Some functions from other sections of POSIX
1003.1 2001 are also supported including semaphores and scheduling
functions.
Some common non-portable functions are also implemented for
additional compatibility, as are a few functions specific
to pthreads-win32 for easier integration with Win32 applications.
Pthreads-win32 is free software, distributed under the GNU Lesser
General Public License (LGPL).
Acknowledgements
----------------
This library is based originally on a Win32 pthreads
implementation contributed by John Bossom.
The implementation of Condition Variables uses algorithms developed
by Alexander Terekhov and Louis Thomas.
The implementation of POSIX mutexes has been improved by Thomas Pfaff
and later by Alexander Terekhov.
The implementation of Spinlocks and Barriers was contributed
by Ross Johnson.
The implementation of read/write locks was contributed by
Aurelio Medina and improved by Alexander Terekhov.
Many others have contributed significant time and effort to solve crutial
problems in order to make the library workable, robust and reliable.
Thanks to Xavier Leroy for granting permission to use and modify his
LinuxThreads manual pages.
Thanks to The Open Group for making the Single Unix Specification
publicly available - many of the manual pages included in the package
were extracted from it.
There is also a separate CONTRIBUTORS file. This file and others are
on the web site:
http://sourceware.org/pthreads-win32
As much as possible, the ChangeLog file acknowledges contributions to the
code base in more detail.
Changes since the last release
------------------------------
These are now documented in the NEWS file.
See the ChangeLog file also.
Known Bugs
----------
These are now documented in the BUGS file.
Level of standards conformance
------------------------------
The following POSIX 1003.1 2001 options are defined and set to 200112L:
_POSIX_THREADS
_POSIX_THREAD_SAFE_FUNCTIONS
_POSIX_THREAD_ATTR_STACKSIZE
_POSIX_THREAD_PRIORITY_SCHEDULING
_POSIX_SEMAPHORES
_POSIX_READER_WRITER_LOCKS
_POSIX_SPIN_LOCKS
_POSIX_BARRIERS
The following POSIX 1003.1 2001 options are defined and set to -1:
_POSIX_THREAD_ATTR_STACKADDR
_POSIX_THREAD_PRIO_INHERIT
_POSIX_THREAD_PRIO_PROTECT
_POSIX_THREAD_PROCESS_SHARED
The following POSIX 1003.1 2001 limits are defined and set:
_POSIX_THREAD_THREADS_MAX
_POSIX_SEM_VALUE_MAX
_POSIX_SEM_NSEMS_MAX
_POSIX_THREAD_KEYS_MAX
_POSIX_THREAD_DESTRUCTOR_ITERATIONS
PTHREAD_STACK_MIN
PTHREAD_THREADS_MAX
SEM_VALUE_MAX
SEM_NSEMS_MAX
PTHREAD_KEYS_MAX
PTHREAD_DESTRUCTOR_ITERATIONS
The following functions are implemented:
---------------------------
PThreads
---------------------------
pthread_attr_init
pthread_attr_destroy
pthread_attr_getdetachstate
pthread_attr_getstackaddr
pthread_attr_getstacksize
pthread_attr_setdetachstate
pthread_attr_setstackaddr
pthread_attr_setstacksize
pthread_create
pthread_detach
pthread_equal
pthread_exit
pthread_join
pthread_once
pthread_self
pthread_cancel
pthread_cleanup_pop
pthread_cleanup_push
pthread_setcancelstate
pthread_setcanceltype
pthread_testcancel
---------------------------
Thread Specific Data
---------------------------
pthread_key_create
pthread_key_delete
pthread_setspecific
pthread_getspecific
---------------------------
Mutexes
---------------------------
pthread_mutexattr_init
pthread_mutexattr_destroy
pthread_mutexattr_getpshared
pthread_mutexattr_setpshared
pthread_mutexattr_gettype
pthread_mutexattr_settype (types: PTHREAD_MUTEX_DEFAULT
PTHREAD_MUTEX_NORMAL
PTHREAD_MUTEX_ERRORCHECK
PTHREAD_MUTEX_RECURSIVE )
pthread_mutexattr_getrobust
pthread_mutexattr_setrobust (values: PTHREAD_MUTEX_STALLED
PTHREAD_MUTEX_ROBUST)
pthread_mutex_init
pthread_mutex_destroy
pthread_mutex_lock
pthread_mutex_trylock
pthread_mutex_timedlock
pthread_mutex_unlock
pthread_mutex_consistent
---------------------------
Condition Variables
---------------------------
pthread_condattr_init
pthread_condattr_destroy
pthread_condattr_getpshared
pthread_condattr_setpshared
pthread_cond_init
pthread_cond_destroy
pthread_cond_wait
pthread_cond_timedwait
pthread_cond_signal
pthread_cond_broadcast
---------------------------
Read/Write Locks
---------------------------
pthread_rwlock_init
pthread_rwlock_destroy
pthread_rwlock_tryrdlock
pthread_rwlock_trywrlock
pthread_rwlock_rdlock
pthread_rwlock_timedrdlock
pthread_rwlock_rwlock
pthread_rwlock_timedwrlock
pthread_rwlock_unlock
pthread_rwlockattr_init
pthread_rwlockattr_destroy
pthread_rwlockattr_getpshared
pthread_rwlockattr_setpshared
---------------------------
Spin Locks
---------------------------
pthread_spin_init
pthread_spin_destroy
pthread_spin_lock
pthread_spin_unlock
pthread_spin_trylock
---------------------------
Barriers
---------------------------
pthread_barrier_init
pthread_barrier_destroy
pthread_barrier_wait
pthread_barrierattr_init
pthread_barrierattr_destroy
pthread_barrierattr_getpshared
pthread_barrierattr_setpshared
---------------------------
Semaphores
---------------------------
sem_init
sem_destroy
sem_post
sem_wait
sem_trywait
sem_timedwait
sem_getvalue (# free if +ve, # of waiters if -ve)
sem_open (returns an error ENOSYS)
sem_close (returns an error ENOSYS)
sem_unlink (returns an error ENOSYS)
---------------------------
RealTime Scheduling
---------------------------
pthread_attr_getschedparam
pthread_attr_setschedparam
pthread_attr_getinheritsched
pthread_attr_setinheritsched
pthread_attr_getschedpolicy (only supports SCHED_OTHER)
pthread_attr_setschedpolicy (only supports SCHED_OTHER)
pthread_getschedparam
pthread_setschedparam
pthread_getconcurrency
pthread_setconcurrency
pthread_attr_getscope
pthread_attr_setscope (only supports PTHREAD_SCOPE_SYSTEM)
sched_get_priority_max
sched_get_priority_min
sched_rr_get_interval (returns an error ENOTSUP)
sched_setscheduler (only supports SCHED_OTHER)
sched_getscheduler (only supports SCHED_OTHER)
sched_yield
---------------------------
Signals
---------------------------
pthread_sigmask
pthread_kill (only supports zero sig value,
for thread validity checking)
---------------------------
Non-portable routines (see the README.NONPORTABLE file for usage)
---------------------------
pthread_getw32threadhandle_np
pthread_timechange_handler_np
pthread_delay_np
pthread_getunique_np
pthread_mutexattr_getkind_np
pthread_mutexattr_setkind_np (types: PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ADAPTIVE_NP,
PTHREAD_MUTEX_TIMED_NP)
pthread_num_processors_np
(The following four routines may be required when linking statically.
The process_* routines should not be needed for MSVC or GCC.)
pthread_win32_process_attach_np
pthread_win32_process_detach_np
(The following routines should only be needed to manage implicit
POSIX handles i.e. when Win native threads call POSIX thread routines
(other than pthread_create))
pthread_win32_thread_attach_np
pthread_win32_thread_detach_np
---------------------------
Static Initializers
---------------------------
PTHREAD_ONCE_INIT
PTHREAD_MUTEX_INITIALIZER
PTHREAD_RECURSIVE_MUTEX_INITIALIZER
PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
PTHREAD_COND_INITIALIZER
PTHREAD_RWLOCK_INITIALIZER
PTHREAD_SPINLOCK_INITIALIZER
The library includes two non-API functions for creating cancellation
points in applications and libraries:
pthreadCancelableWait
pthreadCancelableTimedWait
The following functions are not implemented:
---------------------------
RealTime Scheduling
---------------------------
pthread_mutex_getprioceiling
pthread_mutex_setprioceiling
pthread_mutex_attr_getprioceiling
pthread_mutex_attr_getprotocol
pthread_mutex_attr_setprioceiling
pthread_mutex_attr_setprotocol
---------------------------
Fork Handlers
---------------------------
pthread_atfork
---------------------------
Stdio
---------------------------
flockfile
ftrylockfile
funlockfile
getc_unlocked
getchar_unlocked
putc_unlocked
putchar_unlocked
---------------------------
Thread-Safe C Runtime Library
---------------------------
readdir_r
getgrgid_r
getgrnam_r
getpwuid_r
getpwnam_r
---------------------------
Signals
---------------------------
sigtimedwait
sigwait
sigwaitinfo
---------------------------
General
---------------------------
sysconf
---------------------------
Thread-Safe C Runtime Library (macros)
---------------------------
strtok_r
asctime_r
ctime_r
gmtime_r
localtime_r
rand_r
Availability
------------
The prebuilt DLL, export libs (for both MSVC and Mingw32), and the header
files (pthread.h, semaphore.h, sched.h) are available along with the
complete source code.
The source code can be found at:
ftp://sources.redhat.com/pub/pthreads-win32
and as individual source code files at
ftp://sources.redhat.com/pub/pthreads-win32/source
The pre-built DLL, export libraries and include files can be found at:
ftp://sources.redhat.com/pub/pthreads-win32/dll-latest
Mailing List
------------
There is a mailing list for discussing pthreads on Win32. To join,
send email to:
pthreads-win32-subscribe@sourceware.cygnus.com
Application Development Environments
------------------------------------
See the README file for more information.
MSVC:
MSVC using SEH works. Distribute pthreadVSE.dll with your application.
MSVC using C++ EH works. Distribute pthreadVCE.dll with your application.
MSVC using C setjmp/longjmp works. Distribute pthreadVC.dll with your application.
Mingw32:
See the FAQ, Questions 6 and 10.
Mingw using C++ EH works. Distribute pthreadGCE.dll with your application.
Mingw using C setjmp/longjmp works. Distribute pthreadGC.dll with your application.
Cygwin: (http://sourceware.cygnus.com/cygwin/)
Developers using Cygwin do not need pthreads-win32 since it has POSIX threads
support. Refer to its documentation for details and extent.
UWIN:
UWIN is a complete Unix-like environment for Windows from AT&T. Pthreads-win32
doesn't currently support UWIN (and vice versa), but that may change in the
future.
Generally:
For convenience, the following pre-built files are available on the FTP site
(see Availability above):
pthread.h - for POSIX threads
semaphore.h - for POSIX semaphores
sched.h - for POSIX scheduling
pthreadVCE.dll - built with MSVC++ compiler using C++ EH
pthreadVCE.lib
pthreadVC.dll - built with MSVC compiler using C setjmp/longjmp
pthreadVC.lib
pthreadVSE.dll - built with MSVC compiler using SEH
pthreadVSE.lib
pthreadGCE.dll - built with Mingw32 G++ 2.95.2-1
pthreadGC.dll - built with Mingw32 GCC 2.95.2-1 using setjmp/longjmp
libpthreadGCE.a - derived from pthreadGCE.dll
libpthreadGC.a - derived from pthreadGC.dll
gcc.dll - needed if distributing applications that use
pthreadGCE.dll (but see the FAQ Q 10 for the latest
related information)
These are the only files you need in order to build POSIX threads
applications for Win32 using either MSVC or Mingw32.
See the FAQ file in the source tree for additional information.
Documentation
-------------
For the authoritative reference, see the online POSIX
standard reference at:
http://www.OpenGroup.org
For POSIX Thread API programming, several reference books are
available:
Programming with POSIX Threads
David R. Butenhof
Addison-Wesley (pub)
Pthreads Programming
By Bradford Nichols, Dick Buttlar & Jacqueline Proulx Farrell
O'Reilly (pub)
On the web: see the links at the bottom of the pthreads-win32 site:
http://sources.redhat.com/pthreads-win32/
Currently, there is no documentation included in the package apart
from the copious comments in the source code.
Enjoy!
Ross Johnson

141
3rdparty/pthreads4w/BUGS vendored
View File

@ -1,141 +0,0 @@
----------
Known bugs
----------
1. Not strictly a bug, more of a gotcha.
Under MS VC++ (only tested with version 6.0), a term_func
set via the standard C++ set_terminate() function causes the
application to abort.
Notes from the MSVC++ manual:
1) A term_func() should call exit(), otherwise
abort() will be called on return to the caller.
A call to abort() raises SIGABRT and the default signal handler
for all signals terminates the calling program with
exit code 3.
2) A term_func() must not throw an exception. Therefore
term_func() should not call pthread_exit(), which
works by throwing an exception (pthreadVCE or pthreadVSE)
or by calling longjmp (pthreadVC).
Workaround: avoid using pthread_exit() in C++ applications. Exit
threads by dropping through the end of the thread routine.
2. Cancellation problems in C++ builds
- Milan Gardian
[Note: It's not clear if this problem isn't simply due to the context
switch in pthread_cancel() which occurs unless the QueueUserAPCEx
library and driver are installed and used. Just like setjmp/longjmp,
this is probably not going to work well in C++. In any case, unless for
some very unusual reason you really must use the C++ build then please
use the C build pthreadVC2.dll or pthreadGC2.dll, i.e. for C++
applications.]
This is suspected to be a compiler bug in VC6.0, and also seen in
VC7.0 and VS .NET 2003. The GNU C++ compiler does not have a problem
with this, and it has been reported that the Intel C++ 8.1 compiler
and Visual C++ 2005 Express Edition Beta2 pass tests\semaphore4.c
(which exposes the bug).
Workaround [rpj - 2 Feb 2002]
-----------------------------
[Please note: this workaround did not solve a similar problem in
snapshot-2004-11-03 or later, even though similar symptoms were seen.
tests\semaphore4.c fails in that snapshot for the VCE version of the
DLL.]
The problem disappears when /Ob0 is used, i.e. /O2 /Ob0 works OK,
but if you want to use inlining optimisation you can be much more
specific about where it's switched off and on by using a pragma.
So the inlining optimisation is interfering with the way that cleanup
handlers are run. It appears to relate to auto-inlining of class methods
since this is the only auto inlining that is performed at /O1 optimisation
(functions with the "inline" qualifier are also inlined, but the problem
doesn't appear to involve any such functions in the library or testsuite).
In order to confirm the inlining culprit, the following use of pragmas
eliminate the problem but I don't know how to make it transparent, putting
it in, say, pthread.h where pthread_cleanup_push defined as a macro.
#pragma inline_depth(0)
pthread_cleanup_push(handlerFunc, (void *) &arg);
/* ... */
pthread_cleanup_pop(0);
#pragma inline_depth()
Note the empty () pragma value after the pop macro. This resets depth to the
default. Or you can specify a non-zero depth here.
The pragma is also needed (and now used) within the library itself wherever
cleanup handlers are used (condvar.c and rwlock.c).
Use of these pragmas allows compiler optimisations /O1 and /O2 to be
used for either or both the library and applications.
Experimenting further, I found that wrapping the actual cleanup handler
function with #pragma auto_inline(off|on) does NOT work.
MSVC6.0 doesn't appear to support the C99 standard's _Pragma directive,
however, later versions may. This form is embeddable inside #define
macros, which would be ideal because it would mean that it could be added
to the push/pop macro definitions in pthread.h and hidden from the
application programmer.
[/rpj]
Original problem description
----------------------------
The cancellation (actually, cleanup-after-cancel) tests fail when using VC
(professional) optimisation switches (/O1 or /O2) in pthreads library. I
have not investigated which concrete optimisation technique causes this
problem (/Og, /Oi, /Ot, /Oy, /Ob1, /Gs, /Gf, /Gy, etc.), but here is a
summary of builds and corresponding failures:
* pthreads VSE (optimised tests): OK
* pthreads VCE (optimised tests): Failed "cleanup1" test (runtime)
* pthreads VSE (DLL in CRT, optimised tests): OK
* pthreads VCE (DLL in CRT, optimised tests): Failed "cleanup1" test
(runtime)
Please note that while in VSE version of the pthreads library the
optimisation does not really have any impact on the tests (they pass OK), in
VCE version addition of optimisation (/O2 in this case) causes the tests to
fail uniformly - either in "cleanup0" or "cleanup1" test cases.
Please note that all the tests above use default pthreads DLL (no
optimisations, linked with either static or DLL CRT, based on test type).
Therefore the problem lies not within the pthreads DLL but within the
compiled client code (the application using pthreads -> involvement of
"pthread.h").
I think the message of this section is that usage of VCE version of pthreads
in applications relying on cancellation/cleanup AND using optimisations for
creation of production code is highly unreliable for the current version of
the pthreads library.
3. The Borland Builder 5.5 version of the library produces memory read exceptions
in some tests.
4. pthread_barrier_wait() can deadlock if the number of potential calling
threads for a particular barrier is greater than the barrier count parameter
given to pthread_barrier_init() for that barrier.
This is due to the very lightweight implementation of pthread-win32 barriers.
To cope with more than "count" possible waiters, barriers must effectively
implement all the same safeguards as condition variables, making them much
"heavier" than at present.
The workaround is to ensure that no more than "count" threads attempt to wait
at the barrier.
5. Canceling a thread blocked on pthread_once appears not to work in the MSVC++
version of the library "pthreadVCE.dll". The test case "once3.c" hangs. I have no
clues on this at present. All other versions pass this test ok - pthreadsVC.dll,
pthreadsVSE.dll, pthreadsGC.dll and pthreadsGCE.dll.

268
3rdparty/pthreads4w/Bmakefile vendored
View File

@ -1,268 +0,0 @@
# This makefile is compatible with BCB make. Use "make -fBMakefile" to compile.
#
# The variables $DLLDEST and $LIBDEST hold the destination directories for the
# dll and the lib, respectively. Probably all that needs to change is $DEVROOT.
#
# Currently only the recommended pthreadBC.dll is built by this makefile.
#
DLL_VER = 2
DEVROOT = .
DLLDEST = $(DEVROOT)\DLL
LIBDEST = $(DEVROOT)\DLL
DLLS = pthreadBC$(DLL_VER).dll
OPTIM = /O2
RC = brcc32
RCFLAGS = -i.
CFLAGS = /q /I. /D_WIN32_WINNT=0x400 /DHAVE_PTW32_CONFIG_H=1 /4 /tWD /tWM \
/w-aus /w-asc /w-par
#C cleanup code
BCFLAGS = $(PTW32_FLAGS) $(CFLAGS)
# Agregate modules for inlinability
DLL_OBJS = \
attr.obj \
barrier.obj \
cancel.obj \
cleanup.obj \
condvar.obj \
create.obj \
dll.obj \
errno.obj \
exit.obj \
fork.obj \
global.obj \
misc.obj \
mutex.obj \
nonportable.obj \
private.obj \
rwlock.obj \
sched.obj \
semaphore.obj \
signal.obj \
spin.obj \
sync.obj \
tsd.obj
INCL = config.h implement.h semaphore.h pthread.h need_errno.h
ATTR_SRCS = \
pthread_attr_init.c \
pthread_attr_destroy.c \
pthread_attr_getdetachstate.c \
pthread_attr_setdetachstate.c \
pthread_attr_getstackaddr.c \
pthread_attr_setstackaddr.c \
pthread_attr_getstacksize.c \
pthread_attr_setstacksize.c \
pthread_attr_getscope.c \
pthread_attr_setscope.c
BARRIER_SRCS = \
pthread_barrier_init.c \
pthread_barrier_destroy.c \
pthread_barrier_wait.c \
pthread_barrierattr_init.c \
pthread_barrierattr_destroy.c \
pthread_barrierattr_setpshared.c \
pthread_barrierattr_getpshared.c
CANCEL_SRCS = \
pthread_setcancelstate.c \
pthread_setcanceltype.c \
pthread_testcancel.c \
pthread_cancel.c
CONDVAR_SRCS = \
ptw32_cond_check_need_init.c \
pthread_condattr_destroy.c \
pthread_condattr_getpshared.c \
pthread_condattr_init.c \
pthread_condattr_setpshared.c \
pthread_cond_destroy.c \
pthread_cond_init.c \
pthread_cond_signal.c \
pthread_cond_wait.c
EXIT_SRCS = \
pthread_exit.c
MISC_SRCS = \
pthread_equal.c \
pthread_getconcurrency.c \
pthread_once.c \
pthread_self.c \
pthread_setconcurrency.c \
ptw32_calloc.c \
ptw32_MCS_lock.c \
ptw32_new.c \
w32_CancelableWait.c
MUTEX_SRCS = \
ptw32_mutex_check_need_init.c \
pthread_mutex_init.c \
pthread_mutex_destroy.c \
pthread_mutexattr_init.c \
pthread_mutexattr_destroy.c \
pthread_mutexattr_getpshared.c \
pthread_mutexattr_setpshared.c \
pthread_mutexattr_settype.c \
pthread_mutexattr_gettype.c \
pthread_mutexattr_setrobust.c \
pthread_mutexattr_getrobust.c \
pthread_mutex_lock.c \
pthread_mutex_timedlock.c \
pthread_mutex_unlock.c \
pthread_mutex_trylock.c \
pthread_mutex_consistent.c
NONPORTABLE_SRCS = \
pthread_mutexattr_setkind_np.c \
pthread_mutexattr_getkind_np.c \
pthread_getw32threadhandle_np.c \
pthread_delay_np.c \
pthread_num_processors_np.c \
pthread_win32_attach_detach_np.c \
pthread_timechange_handler_np.c
PRIVATE_SRCS = \
ptw32_is_attr.c \
ptw32_processInitialize.c \
ptw32_processTerminate.c \
ptw32_threadStart.c \
ptw32_threadDestroy.c \
ptw32_tkAssocCreate.c \
ptw32_tkAssocDestroy.c \
ptw32_callUserDestroyRoutines.c \
ptw32_timespec.c \
ptw32_relmillisecs.c \
ptw32_throw.c \
ptw32_getprocessors.c
RWLOCK_SRCS = \
ptw32_rwlock_check_need_init.c \
ptw32_rwlock_cancelwrwait.c \
pthread_rwlock_init.c \
pthread_rwlock_destroy.c \
pthread_rwlockattr_init.c \
pthread_rwlockattr_destroy.c \
pthread_rwlockattr_getpshared.c \
pthread_rwlockattr_setpshared.c \
pthread_rwlock_rdlock.c \
pthread_rwlock_timedrdlock.c \
pthread_rwlock_wrlock.c \
pthread_rwlock_timedwrlock.c \
pthread_rwlock_unlock.c \
pthread_rwlock_tryrdlock.c \
pthread_rwlock_trywrlock.c
SCHED_SRCS = \
pthread_attr_setschedpolicy.c \
pthread_attr_getschedpolicy.c \
pthread_attr_setschedparam.c \
pthread_attr_getschedparam.c \
pthread_attr_setinheritsched.c \
pthread_attr_getinheritsched.c \
pthread_setschedparam.c \
pthread_getschedparam.c \
sched_get_priority_max.c \
sched_get_priority_min.c \
sched_setscheduler.c \
sched_getscheduler.c \
sched_yield.c
SEMAPHORE_SRCS = \
sem_init.c \
sem_destroy.c \
sem_trywait.c \
sem_timedwait.c \
sem_wait.c \
sem_post.c \
sem_post_multiple.c \
sem_getvalue.c \
sem_open.c \
sem_close.c \
sem_unlink.c
SPIN_SRCS = \
ptw32_spinlock_check_need_init.c \
pthread_spin_init.c \
pthread_spin_destroy.c \
pthread_spin_lock.c \
pthread_spin_unlock.c \
pthread_spin_trylock.c
SYNC_SRCS = \
pthread_detach.c \
pthread_join.c
TSD_SRCS = \
pthread_key_create.c \
pthread_key_delete.c \
pthread_setspecific.c \
pthread_getspecific.c
all: clean $(DLLS)
realclean: clean
if exist pthread*.dll del pthread*.dll
if exist pthread*.lib del pthread*.lib
if exist *.stamp del *.stamp
clean:
if exist *.obj del *.obj
if exist *.ilk del *.ilk
if exist *.ilc del *.ilc
if exist *.ild del *.ild
if exist *.ilf del *.ilf
if exist *.ils del *.ils
if exist *.tds del *.tds
if exist *.pdb del *.pdb
if exist *.exp del *.exp
if exist *.map del *.map
if exist *.o del *.o
if exist *.i del *.i
if exist *.res del *.res
install: $(DLLS)
copy pthread*.dll $(DLLDEST)
copy pthread*.lib $(LIBDEST)
$(DLLS): $(DLL_OBJS) version.res
ilink32 /Tpd /Gi c0d32x.obj $(DLL_OBJS), \
$@, ,\
cw32mti.lib import32.lib, ,\
version.res
.c.obj:
$(CC) $(OPTIM) $(BCFLAGS) -c $<
.rc.res:
$(RC) $(RCFLAGS) $<
attr.obj: attr.c $(ATTR_SRCS) $(INCL)
barrier.obj: barrier.c $(BARRIER_SRCS) $(INCL)
cancel.obj: cancel.c $(CANCEL_SRCS) $(INCL)
condvar.obj: condvar.c $(CONDVAR_SRCS) $(INCL)
exit.obj: exit.c $(EXIT_SRCS) $(INCL)
misc.obj: misc.c $(MISC_SRCS) $(INCL)
mutex.obj: mutex.c $(MUTEX_SRCS) $(INCL)
nonportable.obj: nonportable.c $(NONPORTABLE_SRCS) $(INCL)
private.obj: private.c $(PRIVATE_SRCS) $(INCL)
rwlock.obj: rwlock.c $(RWLOCK_SRCS) $(INCL)
sched.obj: sched.c $(SCHED_SRCS) $(INCL)
semaphore.obj: semaphore.c $(SEMAPHORE_SRCS) $(INCL)
spin.obj: spin.c $(SPIN_SRCS) $(INCL)
sync.obj: sync.c $(SYNC_SRCS) $(INCL)
tsd.obj: tsd.c $(TSD_SRCS) $(INCL)
version.res: version.rc $(INCL)

11
3rdparty/pthreads4w/CMakeLists.txt vendored
View File

@ -1,11 +0,0 @@
add_library(pthreads4w
pthread.c
config.h
context.h
include/pthread.h
include/sched.h
include/semaphore.h
need_errno.h
)
target_compile_definitions(pthreads4w PUBLIC PTW32_STATIC_LIB __CLEANUP_SEH PRIVATE HAVE_PTW32_CONFIG_H PTW32_BUILD_INLINED)
target_include_directories(pthreads4w PUBLIC include)

140
3rdparty/pthreads4w/CONTRIBUTORS vendored
View File

@ -1,140 +0,0 @@
Contributors (in approximate order of appearance)
[See also the ChangeLog file where individuals are
attributed in log entries. Likewise in the FAQ file.]
Ben Elliston bje at cygnus dot com
Initiated the project;
setup the project infrastructure (CVS, web page, etc.);
early prototype routines.
Ross Johnson Ross dot Johnson at dot homemail dot com dot au
early prototype routines;
ongoing project coordination/maintenance;
implementation of spin locks and barriers;
various enhancements;
bug fixes;
documentation;
testsuite.
Robert Colquhoun rjc at trump dot net dot au
Early bug fixes.
John E. Bossom John dot Bossom at cognos dot com
Contributed substantial original working implementation;
bug fixes;
ongoing guidance and standards interpretation.
Anders Norlander anorland at hem2 dot passagen dot se
Early enhancements and runtime checking for supported
Win32 routines.
Tor Lillqvist tml at iki dot fi
General enhancements;
early bug fixes to condition variables.
Scott Lightner scott at curriculum dot com
Bug fix.
Kevin Ruland Kevin dot Ruland at anheuser-busch dot com
Various bug fixes.
Mike Russo miker at eai dot com
Bug fix.
Mark E. Armstrong avail at pacbell dot net
Bug fixes.
Lorin Hochstein lmh at xiphos dot ca
general bug fixes; bug fixes to condition variables.
Peter Slacik Peter dot Slacik at tatramed dot sk
Bug fixes.
Mumit Khan khan at xraylith dot wisc dot edu
Fixes to work with Mingw32.
Milan Gardian mg at tatramed dot sk
Bug fixes and reports/analyses of obscure problems.
Aurelio Medina aureliom at crt dot com
First implementation of read-write locks.
Graham Dumpleton Graham dot Dumpleton at ra dot pad dot otc dot telstra dot com dot au
Bug fix in condition variables.
Tristan Savatier tristan at mpegtv dot com
WinCE port.
Erik Hensema erik at hensema dot xs4all dot nl
Bug fixes.
Rich Peters rpeters at micro-magic dot com
Todd Owen towen at lucidcalm dot dropbear dot id dot au
Bug fixes to dll loading.
Jason Nye jnye at nbnet dot nb dot ca
Implementation of async cancelation.
Fred Forester fforest at eticomm dot net
Kevin D. Clark kclark at cabletron dot com
David Baggett dmb at itasoftware dot com
Bug fixes.
Paul Redondo paul at matchvision dot com
Scott McCaskill scott at 3dfx dot com
Bug fixes.
Jef Gearhart jgearhart at tpssys dot com
Bug fix.
Arthur Kantor akantor at bexusa dot com
Mutex enhancements.
Steven Reddie smr at essemer dot com dot au
Bug fix.
Alexander Terekhov TEREKHOV at de dot ibm dot com
Re-implemented and improved read-write locks;
(with Louis Thomas) re-implemented and improved
condition variables;
enhancements to semaphores;
enhancements to mutexes;
new mutex implementation in 'futex' style;
suggested a robust implementation of pthread_once
similar to that implemented by V.Kliathcko;
system clock change handling re CV timeouts;
bug fixes.
Thomas Pfaff tpfaff at gmx dot net
Changes to make C version usable with C++ applications;
re-implemented mutex routines to avoid Win32 mutexes
and TryEnterCriticalSection;
procedure to fix Mingw32 thread-safety issues.
Franco Bez franco dot bez at gmx dot de
procedure to fix Mingw32 thread-safety issues.
Louis Thomas lthomas at arbitrade dot com
(with Alexander Terekhov) re-implemented and improved
condition variables.
David Korn dgk at research dot att dot com
Ported to UWIN.
Phil Frisbie, Jr. phil at hawksoft dot com
Bug fix.
Ralf Brese Ralf dot Brese at pdb4 dot siemens dot de
Bug fix.
prionx at juno dot com prionx at juno dot com
Bug fixes.
Max Woodbury mtew at cds dot duke dot edu
POSIX versioning conditionals;
reduced namespace pollution;
idea to separate routines to reduce statically
linked image sizes.
Rob Fanner rfanner at stonethree dot com
Bug fix.
Michael Johnson michaelj at maine dot rr dot com
Bug fix.
Nicolas Barry boozai at yahoo dot com
Bug fixes.
Piet van Bruggen pietvb at newbridges dot nl
Bug fix.
Makoto Kato raven at oldskool dot jp
AMD64 port.
Panagiotis E. Hadjidoukas peh at hpclab dot ceid dot upatras dot gr
phadjido at cs dot uoi dot gr
Contributed the QueueUserAPCEx package which
makes preemptive async cancelation possible.
Will Bryant will dot bryant at ecosm dot com
Borland compiler patch and makefile.
Anuj Goyal anuj dot goyal at gmail dot com
Port to Digital Mars compiler.
Gottlob Frege gottlobfrege at gmail dot com
re-implemented pthread_once (version 2)
(pthread_once cancellation added by rpj).
Vladimir Kliatchko vladimir at kliatchko dot com
reimplemented pthread_once with the same form
as described by A.Terekhov (later version 2);
implementation of MCS (Mellor-Crummey/Scott) locks.
Ramiro Polla ramiro.polla at gmail dot com
static library auto init/cleanup on application
start/exit via RT hooks (MSC and GCC compilers only).
Daniel Richard G. skunk at iSKUNK dot org
Patches and cleanups for x86 and x64, particularly
across a range of MS build environments.
John Kamp john dot kamp at globalgraphics dot com
Patches to fix various problems on x64; brutal testing
particularly using high memory run environments.

150
3rdparty/pthreads4w/COPYING vendored
View File

@ -1,150 +0,0 @@
pthreads-win32 - a POSIX threads library for Microsoft Windows
This file is Copyrighted
------------------------
This file is covered under the following Copyright:
Copyright (C) 2001,2006 Ross P. Johnson
All rights reserved.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Pthreads-win32 is covered by the GNU Lesser General Public License
------------------------------------------------------------------
Pthreads-win32 is open 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 version 2.1 of the
License.
Pthreads-win32 is several binary link libraries, several modules,
associated interface definition files and scripts used to control
its compilation and installation.
Pthreads-win32 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.
A copy of the GNU Lesser General Public License is distributed with
pthreads-win32 under the filename:
COPYING.LIB
You should have received a copy of the version 2.1 GNU Lesser General
Public License with pthreads-win32; if not, write to:
Free Software Foundation, Inc.
59 Temple Place
Suite 330
Boston, MA 02111-1307
USA
The contact addresses for pthreads-win32 is as follows:
Web: http://sources.redhat.com/pthreads-win32
Email: Ross Johnson
Please use: Firstname.Lastname@homemail.com.au
Pthreads-win32 copyrights and exception files
---------------------------------------------
With the exception of the files listed below, Pthreads-win32
is covered under the following GNU Lesser General Public License
Copyrights:
Pthreads-win32 - POSIX Threads Library for Win32
Copyright(C) 1998 John E. Bossom
Copyright(C) 1999,2006 Pthreads-win32 contributors
The current list of contributors is contained
in the file CONTRIBUTORS included with the source
code distribution. The current list of CONTRIBUTORS
can also be seen at the following WWW location:
http://sources.redhat.com/pthreads-win32/contributors.html
Contact Email: Ross Johnson
Please use: Firstname.Lastname@homemail.com.au
These files are not covered under one of the Copyrights listed above:
COPYING
COPYING.LIB
tests/rwlock7.c
This file, COPYING, is distributed under the Copyright found at the
top of this file. It is important to note that you may distribute
verbatim copies of this file but you may not modify this file.
The file COPYING.LIB, which contains a copy of the version 2.1
GNU Lesser General Public License, is itself copyrighted by the
Free Software Foundation, Inc. Please note that the Free Software
Foundation, Inc. does NOT have a copyright over Pthreads-win32,
only the COPYING.LIB that is supplied with pthreads-win32.
The file tests/rwlock7.c is derived from code written by
Dave Butenhof for his book 'Programming With POSIX(R) Threads'.
The original code was obtained by free download from his website
http://home.earthlink.net/~anneart/family/Threads/source.html
and did not contain a copyright or author notice. It is assumed to
be freely distributable.
In all cases one may use and distribute these exception files freely.
And because one may freely distribute the LGPL covered files, the
entire pthreads-win32 source may be freely used and distributed.
General Copyleft and License info
---------------------------------
For general information on Copylefts, see:
http://www.gnu.org/copyleft/
For information on GNU Lesser General Public Licenses, see:
http://www.gnu.org/copyleft/lesser.html
http://www.gnu.org/copyleft/lesser.txt
Why pthreads-win32 did not use the GNU General Public License
-------------------------------------------------------------
The goal of the pthreads-win32 project has been to
provide a quality and complete implementation of the POSIX
threads API for Microsoft Windows within the limits imposed
by virtue of it being a stand-alone library and not
linked directly to other POSIX compliant libraries. For
example, some functions and features, such as those based
on POSIX signals, are missing.
Pthreads-win32 is a library, available in several different
versions depending on supported compilers, and may be used
as a dynamically linked module or a statically linked set of
binary modules. It is not an application on it's own.
It was fully intended that pthreads-win32 be usable with
commercial software not covered by either the GPL or the LGPL
licenses. Pthreads-win32 has many contributors to it's
code base, many of whom have done so because they have
used the library in commercial or proprietry software
projects.
Releasing pthreads-win32 under the LGPL ensures that the
library can be used widely, while at the same time ensures
that bug fixes and improvements to the pthreads-win32 code
itself is returned to benefit all current and future users
of the library.
Although pthreads-win32 makes it possible for applications
that use POSIX threads to be ported to Win32 platforms, the
broader goal of the project is to encourage the use of open
standards, and in particular, to make it just a little easier
for developers writing Win32 applications to consider
widening the potential market for their products.

504
3rdparty/pthreads4w/COPYING.LIB vendored
View File

@ -1,504 +0,0 @@
GNU LESSER GENERAL PUBLIC LICENSE
Version 2.1, February 1999
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the Lesser GPL. It also counts
as the successor of the GNU Library Public License, version 2, hence
the version number 2.1.]
Preamble
The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
This license, the Lesser General Public License, applies to some
specially designated software packages--typically libraries--of the
Free Software Foundation and other authors who decide to use it. You
can use it too, but we suggest you first think carefully about whether
this license or the ordinary General Public License is the better
strategy to use in any particular case, based on the explanations below.
When we speak of free software, we are referring to freedom of use,
not price. Our General Public Licenses are designed to make sure that
you have the freedom to distribute copies of free software (and charge
for this service if you wish); that you receive source code or can get
it if you want it; that you can change the software and use pieces of
it in new free programs; and that you are informed that you can do
these things.
To protect your rights, we need to make restrictions that forbid
distributors to deny you these rights or to ask you to surrender these
rights. These restrictions translate to certain responsibilities for
you if you distribute copies of the library or if you modify it.
For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link other code with the library, you must provide
complete object files to the recipients, so that they can relink them
with the library after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
We protect your rights with a two-step method: (1) we copyright the
library, and (2) we offer you this license, which gives you legal
permission to copy, distribute and/or modify the library.
To protect each distributor, we want to make it very clear that
there is no warranty for the free library. Also, if the library is
modified by someone else and passed on, the recipients should know
that what they have is not the original version, so that the original
author's reputation will not be affected by problems that might be
introduced by others.
Finally, software patents pose a constant threat to the existence of
any free program. We wish to make sure that a company cannot
effectively restrict the users of a free program by obtaining a
restrictive license from a patent holder. Therefore, we insist that
any patent license obtained for a version of the library must be
consistent with the full freedom of use specified in this license.
Most GNU software, including some libraries, is covered by the
ordinary GNU General Public License. This license, the GNU Lesser
General Public License, applies to certain designated libraries, and
is quite different from the ordinary General Public License. We use
this license for certain libraries in order to permit linking those
libraries into non-free programs.
When a program is linked with a library, whether statically or using
a shared library, the combination of the two is legally speaking a
combined work, a derivative of the original library. The ordinary
General Public License therefore permits such linking only if the
entire combination fits its criteria of freedom. The Lesser General
Public License permits more lax criteria for linking other code with
the library.
We call this license the "Lesser" General Public License because it
does Less to protect the user's freedom than the ordinary General
Public License. It also provides other free software developers Less
of an advantage over competing non-free programs. These disadvantages
are the reason we use the ordinary General Public License for many
libraries. However, the Lesser license provides advantages in certain
special circumstances.
For example, on rare occasions, there may be a special need to
encourage the widest possible use of a certain library, so that it becomes
a de-facto standard. To achieve this, non-free programs must be
allowed to use the library. A more frequent case is that a free
library does the same job as widely used non-free libraries. In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.
In other cases, permission to use a particular library in non-free
programs enables a greater number of people to use a large body of
free software. For example, permission to use the GNU C Library in
non-free programs enables many more people to use the whole GNU
operating system, as well as its variant, the GNU/Linux operating
system.
Although the Lesser General Public License is Less protective of the
users' freedom, it does ensure that the user of a program that is
linked with the Library has the freedom and the wherewithal to run
that program using a modified version of the Library.
The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, whereas the latter must
be combined with the library in order to run.
GNU LESSER GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
0. This License Agreement applies to any software library or other
program which contains a notice placed by the copyright holder or
other authorized party saying it may be distributed under the terms of
this Lesser General Public License (also called "this License").
Each licensee is addressed as "you".
A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
1. You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
2. You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
a) The modified work must itself be a software library.
b) You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
c) You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
d) If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
4. You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
5. A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
6. As an exception to the Sections above, you may also combine or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
a) Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
b) Use a suitable shared library mechanism for linking with the
Library. A suitable mechanism is one that (1) uses at run time a
copy of the library already present on the user's computer system,
rather than copying library functions into the executable, and (2)
will operate properly with a modified version of the library, if
the user installs one, as long as the modified version is
interface-compatible with the version that the work was made with.
c) Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
d) If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
e) Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the materials to be distributed need not include anything that is
normally distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
7. You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
a) Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
b) Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
8. You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
9. You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
10. Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties with
this License.
11. If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
12. If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
13. The Free Software Foundation may publish revised and/or new
versions of the Lesser General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
14. If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
NO WARRANTY
15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Libraries
If you develop a new library, and you want it to be of the greatest
possible use to the public, we recommend making it free software that
everyone can redistribute and change. You can do so by permitting
redistribution under these terms (or, alternatively, under the terms of the
ordinary General Public License).
To apply these terms, attach the following notices to the library. It is
safest to attach them to the start of each source file to most effectively
convey the exclusion of warranty; and each file should have at least the
"copyright" line and a pointer to where the full notice is found.
<one line to give the library's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
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.1 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; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Also add information on how to contact you by electronic and paper mail.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a "copyright disclaimer" for the library, if
necessary. Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
library `Frob' (a library for tweaking knobs) written by James Random Hacker.
<signature of Ty Coon>, 1 April 1990
Ty Coon, President of Vice
That's all there is to it!

5211
3rdparty/pthreads4w/ChangeLog vendored
View File

File diff suppressed because it is too large Load Diff

451
3rdparty/pthreads4w/FAQ vendored
View File

@ -1,451 +0,0 @@
=========================================
PTHREADS-WIN32 Frequently Asked Questions
=========================================
INDEX
-----
Q 1 What is it?
Q 2 Which of the several dll versions do I use?
or,
What are all these pthread*.dll and pthread*.lib files?
Q 3 What is the library naming convention?
Q 4 Cleanup code default style or: it used to work when I built
the library myself, but now it doesn't - why?
Q 5 Why is the default library version now less exception-friendly?
Q 6 Should I use Cygwin or Mingw32 as a development environment?
Q 7 Now that pthreads-win32 builds under Mingw32, why do I get
memory access violations (segfaults)?
Q 8 How do I use pthread.dll for Win32 (Visual C++ 5.0)
Q 9 Cancelation doesn't work for me, why?
Q 10 How do I generate pthreadGCE.dll and libpthreadw32.a for use
with Mingw32?
Q 11 Why isn't pthread_t defined as a scalar (e.g. pointer or int)
like it is for other POSIX threads implementations?
=============================================================================
Q 1 What is it?
---
Pthreads-win32 is an Open Source Software implementation of the
Threads component of the POSIX 1003.1c 1995 Standard for Microsoft's
Win32 environment. Some functions from POSIX 1003.1b are also
supported including semaphores. Other related functions include
the set of read-write lock functions. The library also supports
some of the functionality of the Open Group's Single Unix
specification, version 2, namely mutex types.
See the file "ANNOUNCE" for more information including standards
conformance details and list of supported routines.
------------------------------------------------------------------------------
Q 2 Which of the several dll versions do I use?
--- or,
What are all these pthread*.dll and pthread*.lib files?
Simply, you only use one of them, but you need to choose carefully.
The most important choice you need to make is whether to use a
version that uses exceptions internally, or not (there are versions
of the library that use exceptions as part of the thread
cancelation and cleanup implementation, and one that uses
setjmp/longjmp instead).
There is some contension amongst POSIX threads experts as
to how POSIX threads cancelation and exit should work
with languages that include exceptions and handlers, e.g.
C++ and even C (Microsoft's Structured Exceptions).
The issue is: should cancelation of a thread in, say,
a C++ application cause object destructors and C++ exception
handlers to be invoked as the stack unwinds during thread
exit, or not?
There seems to be more opinion in favour of using the
standard C version of the library (no EH) with C++ applications
since this appears to be the assumption commercial pthreads
implementations make. Therefore, if you use an EH version
of pthreads-win32 then you may be under the illusion that
your application will be portable, when in fact it is likely to
behave very differently linked with other pthreads libraries.
Now you may be asking: why have you kept the EH versions of
the library?
There are a couple of reasons:
- there is division amongst the experts and so the code may
be needed in the future. (Yes, it's in the repository and we
can get it out anytime in the future, but ...)
- pthreads-win32 is one of the few implementations, and possibly
the only freely available one, that has EH versions. It may be
useful to people who want to play with or study application
behaviour under these conditions.
------------------------------------------------------------------------------
Q 3 What is the library naming convention?
---
Because the library is being built using various exception
handling schemes and compilers - and because the library
may not work reliably if these are mixed in an application,
each different version of the library has it's own name.
Note 1: the incompatibility is really between EH implementations
of the different compilers. It should be possible to use the
standard C version from either compiler with C++ applications
built with a different compiler. If you use an EH version of
the library, then you must use the same compiler for the
application. This is another complication and dependency that
can be avoided by using only the standard C library version.
Note 2: if you use a standard C pthread*.dll with a C++
application, then any functions that you define that are
intended to be called via pthread_cleanup_push() must be
__cdecl.
Note 3: the intention is to also name either the VC or GC
version (it should be arbitrary) as pthread.dll, including
pthread.lib and libpthread.a as appropriate.
In general:
pthread[VG]{SE,CE,C}.dll
pthread[VG]{SE,CE,C}.lib
where:
[VG] indicates the compiler
V - MS VC
G - GNU C
{SE,CE,C} indicates the exception handling scheme
SE - Structured EH
CE - C++ EH
C - no exceptions - uses setjmp/longjmp
For example:
pthreadVSE.dll (MSVC/SEH)
pthreadGCE.dll (GNUC/C++ EH)
pthreadGC.dll (GNUC/not dependent on exceptions)
The GNU library archive file names have changed to:
libpthreadGCE.a
libpthreadGC.a
------------------------------------------------------------------------------
Q 4 Cleanup code default style or: it used to work when I built
--- the library myself, but now it doesn't - why?
Up to and including snapshot 2001-07-12, if not defined, the cleanup
style was determined automatically from the compiler used, and one
of the following was defined accordingly:
__CLEANUP_SEH MSVC only
__CLEANUP_CXX C++, including MSVC++, GNU G++
__CLEANUP_C C, including GNU GCC, not MSVC
These defines determine the style of cleanup (see pthread.h) and,
most importantly, the way that cancelation and thread exit (via
pthread_exit) is performed (see the routine ptw32_throw() in private.c).
In short, the exceptions versions of the library throw an exception
when a thread is canceled or exits (via pthread_exit()), which is
caught by a handler in the thread startup routine, so that the
the correct stack unwinding occurs regardless of where the thread
is when it's canceled or exits via pthread_exit().
After snapshot 2001-07-12, unless your build explicitly defines (e.g.
via a compiler option) __CLEANUP_SEH, __CLEANUP_CXX, or __CLEANUP_C, then
the build now ALWAYS defaults to __CLEANUP_C style cleanup. This style
uses setjmp/longjmp in the cancelation and pthread_exit implementations,
and therefore won't do stack unwinding even when linked to applications
that have it (e.g. C++ apps). This is for consistency with most/all
commercial Unix POSIX threads implementations.
Although it was not clearly documented before, it is still necessary to
build your application using the same __CLEANUP_* define as was
used for the version of the library that you link with, so that the
correct parts of pthread.h are included. That is, the possible
defines require the following library versions:
__CLEANUP_SEH pthreadVSE.dll
__CLEANUP_CXX pthreadVCE.dll or pthreadGCE.dll
__CLEANUP_C pthreadVC.dll or pthreadGC.dll
THE POINT OF ALL THIS IS: if you have not been defining one of these
explicitly, then the defaults have been set according to the compiler
and language you are using, as described at the top of this
section.
THIS NOW CHANGES, as has been explained above. For example:
If you were building your application with MSVC++ i.e. using C++
exceptions (rather than SEH) and not explicitly defining one of
__CLEANUP_*, then __CLEANUP_C++ was defined for you in pthread.h.
You should have been linking with pthreadVCE.dll, which does
stack unwinding.
If you now build your application as you had before, pthread.h will now
set __CLEANUP_C as the default style, and you will need to link
with pthreadVC.dll. Stack unwinding will now NOT occur when a
thread is canceled, nor when the thread calls pthread_exit().
Your application will now most likely behave differently to previous
versions, and in non-obvious ways. Most likely is that local
objects may not be destroyed or cleaned up after a thread
is canceled.
If you want the same behaviour as before, then you must now define
__CLEANUP_C++ explicitly using a compiler option and link with
pthreadVCE.dll as you did before.
------------------------------------------------------------------------------
Q 5 Why is the default library version now less exception-friendly?
---
Because most commercial Unix POSIX threads implementations don't allow you to
choose to have stack unwinding. (Compaq's TRU64 Unix is possibly an exception.)
Therefore, providing it in pthread-win32 as a default could be dangerous
and non-portable. We still provide the choice but you must now consciously
make it.
WHY NOT REMOVE THE EXCEPTIONS VERSIONS OF THE LIBRARY ALTOGETHER?
There are a few reasons:
- because there are well respected POSIX threads people who believe
that POSIX threads implementations should be exceptions-aware and
do the expected thing in that context. (There are equally respected
people who believe it should not be easily accessible, if it's there
at all.)
- because pthreads-win32 is one of the few implementations that has
the choice, perhaps the only freely available one, and so offers
a laboratory to people who may want to explore the effects;
- although the code will always be around somewhere for anyone who
wants it, once it's removed from the current version it will not be
nearly as visible to people who may have a use for it.
------------------------------------------------------------------------------
Q 6 Should I use Cygwin or Mingw32 as a development environment?
---
Important: see Q7 also.
Use Mingw32 with the MSVCRT library to build applications that use
the pthreads DLL.
Cygwin's own internal support for POSIX threads is growing.
Consult that project's documentation for more information.
------------------------------------------------------------------------------
Q 7 Now that pthreads-win32 builds under Mingw32, why do I get
--- memory access violations (segfaults)?
The latest Mingw32 package has thread-safe exception handling (see Q10).
Also, see Q6 above.
------------------------------------------------------------------------------
Q 8 How do I use pthread.dll for Win32 (Visual C++ 5.0)
---
>
> I'm a "rookie" when it comes to your pthread implementation. I'm currently
> desperately trying to install the prebuilt .dll file into my MSVC compiler.
> Could you please provide me with explicit instructions on how to do this (or
> direct me to a resource(s) where I can acquire such information)?
>
> Thank you,
>
You should have a .dll, .lib, .def, and three .h files. It is recommended
that you use pthreadVC.dll, rather than pthreadVCE.dll or pthreadVSE.dll
(see Q2 above).
The .dll can go in any directory listed in your PATH environment
variable, so putting it into C:\WINDOWS should work.
The .lib file can go in any directory listed in your LIB environment
variable.
The .h files can go in any directory listed in your INCLUDE
environment variable.
Or you might prefer to put the .lib and .h files into a new directory
and add its path to LIB and INCLUDE. You can probably do this easiest
by editing the file:-
C:\Program Files\DevStudio\vc\bin\vcvars32.bat
The .def file isn't used by anything in the pre-compiled version but
is included for information.
Cheers.
Ross
------------------------------------------------------------------------------
Q 9 Cancelation doesn't work for me, why?
---
> I'm investigating a problem regarding thread cancelation. The thread I want
> to cancel has PTHREAD_CANCEL_ASYNCHRONOUS, however, this piece of code
> blocks on the join():
>
> if ((retv = Pthread_cancel( recvThread )) == 0)
> {
> retv = Pthread_join( recvThread, 0 );
> }
>
> Pthread_* are just macro's; they call pthread_*.
>
> The thread recvThread seems to block on a select() call. It doesn't get
> cancelled.
>
> Two questions:
>
> 1) is this normal behaviour?
>
> 2) if not, how does the cancel mechanism work? I'm not very familliar to
> win32 programming, so I don't really understand how the *Event() family of
> calls work.
The answer to your first question is, normal POSIX behaviour would
be to asynchronously cancel the thread. However, even that doesn't
guarantee cancelation as the standard only says it should be
cancelled as soon as possible.
Snapshot 99-11-02 or earlier only partially supports asynchronous cancellation.
Snapshots since then simulate async cancelation by poking the address of
a cancelation routine into the PC of the threads context. This requires
the thread to be resumed in some way for the cancelation to actually
proceed. This is not true async cancelation, but it is as close as we've
been able to get to it.
If the thread you're trying to cancel is blocked (for instance, it could be
waiting for data from the network), it will only get cancelled when it unblocks
(when the data arrives). For true pre-emptive cancelation in these cases,
pthreads-win32 from snapshot 2004-05-16 can automatically recognise and use the
QueueUserAPCEx package by Panagiotis E. Hadjidoukas. This package is available
from the pthreads-win32 ftp site and is included in the pthreads-win32
self-unpacking zip from 2004-05-16 onwards.
Using deferred cancelation would normally be the way to go, however,
even though the POSIX threads standard lists a number of C library
functions that are defined as deferred cancelation points, there is
no hookup between those which are provided by Windows and the
pthreads-win32 library.
Incidently, it's worth noting for code portability that the older POSIX
threads standards cancelation point lists didn't include "select" because
(as I read in Butenhof) it wasn't part of POSIX. However, it does appear in
the SUSV3.
Effectively, the only mandatory cancelation points that pthreads-win32
recognises are those the library implements itself, ie.
pthread_testcancel
pthread_cond_wait
pthread_cond_timedwait
pthread_join
sem_wait
sem_timedwait
pthread_delay_np
The following routines from the non-mandatory list in SUSV3 are
cancelation points in pthreads-win32:
pthread_rwlock_wrlock
pthread_rwlock_timedwrlock
The following routines from the non-mandatory list in SUSV3 are not
cancelation points in pthreads-win32:
pthread_rwlock_rdlock
pthread_rwlock_timedrdlock
Pthreads-win32 also provides two functions that allow you to create
cancelation points within your application, but only for cases where
a thread is going to block on a Win32 handle. These are:
pthreadCancelableWait(HANDLE waitHandle) /* Infinite wait */
pthreadCancelableTimedWait(HANDLE waitHandle, DWORD timeout)
------------------------------------------------------------------------------
Q 10 How do I create thread-safe applications using
---- pthreadGCE.dll, libpthreadw32.a and Mingw32?
This should not be a problem with recent versions of MinGW32.
For early versions, see Thomas Pfaff's email at:
http://sources.redhat.com/ml/pthreads-win32/2002/msg00000.html
------------------------------------------------------------------------------
Q 11 Why isn't pthread_t defined as a scalar (e.g. pointer or int)
like it is for other POSIX threads implementations?
----
Originally pthread_t was defined as a pointer (to the opaque pthread_t_
struct) and later it was changed to a struct containing the original
pointer plus a sequence counter. This is allowed under both the original
POSIX Threads Standard and the current Single Unix Specification.
When pthread_t is a simple pointer to a struct some very difficult to
debug problems arise from the process of freeing and later allocing
thread structs because new pthread_t handles can acquire the identity of
previously detached threads. The change to a struct was made, along with
some changes to their internal managment, in order to guarantee (for
practical applications) that the pthread_t handle will be unique over the
life of the running process.
Where application code attempts to compare one pthread_t against another
directly, a compiler error will be emitted because structs can't be
compared at that level. This should signal a potentially serious problem
in the code design, which would go undetected if pthread_t was a scalar.
The POSIX Threading API provides a function named pthread_equal() to
compare pthread_t thread handles.
Other pthreads implementations, such as Sun's, use an int as the handle
but do guarantee uniqueness within the process scope. Win32 scalar typed
thread handles also guarantee uniqueness in system scope. It wasn't clear
how well the internal management of these handles would scale as the
number of threads and the fragmentation of the sequence numbering
increased for applications where thousands or millions of threads are
created and detached over time. The current management of threads within
pthreads-win32 using structs for pthread_t, and reusing without ever
freeing them, reduces the management time overheads to a constant, which
could be important given that pthreads-win32 threads are built on top of
Win32 threads and will therefore include that management overhead on top
of their own. The cost is that the memory resources used for thread
handles will remain at the peak level until the process exits.
While it may be inconvenient for developers to be forced away from making
assumptions about the internals of pthread_t, the advantage for the
future development of pthread-win32, as well as those applications that
use it and other pthread implementations, is that the library is free to
change pthread_t internals and management as better methods arise.

593
3rdparty/pthreads4w/GNUmakefile vendored
View File

@ -1,593 +0,0 @@
#
# --------------------------------------------------------------------------
#
# 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
#
DLL_VER = 2
DLL_VERD= $(DLL_VER)d
DEVROOT = C:\PTHREADS
DLLDEST = $(DEVROOT)\DLL
LIBDEST = $(DEVROOT)\DLL
# If Running MsysDTK
RM = rm -f
MV = mv -f
CP = cp -f
# If not.
#RM = erase
#MV = rename
#CP = copy
# For cross compiling use e.g.
# make CROSS=x86_64-w64-mingw32- clean GC-inlined
CROSS =
AR = $(CROSS)ar
DLLTOOL = $(CROSS)dlltool
CC = $(CROSS)gcc
CXX = $(CROSS)g++
RANLIB = $(CROSS)ranlib
RC = $(CROSS)windres
OPT = $(CLEANUP) -O3 # -finline-functions -findirect-inlining
XOPT =
RCFLAGS = --include-dir=.
# Uncomment this if config.h defines RETAIN_WSALASTERROR
#LFLAGS = -lws2_32
# ----------------------------------------------------------------------
# The library can be built with some alternative behaviour to
# facilitate development of applications on Win32 that will be ported
# to other POSIX systems. Nothing definable here will make the library
# non-compliant, but applications that make assumptions that POSIX
# does not garrantee may fail or misbehave under some settings.
#
# PTW32_THREAD_ID_REUSE_INCREMENT
# Purpose:
# POSIX says that applications should assume that thread IDs can be
# recycled. However, Solaris and some other systems use a [very large]
# sequence number as the thread ID, which provides virtual uniqueness.
# Pthreads-win32 provides pseudo-unique IDs when the default increment
# (1) is used, but pthread_t is not a scalar type like Solaris's.
#
# Usage:
# Set to any value in the range: 0 <= value <= 2^wordsize
#
# Examples:
# Set to 0 to emulate non recycle-unique behaviour like Linux or *BSD.
# Set to 1 for recycle-unique thread IDs (this is the default).
# Set to some other +ve value to emulate smaller word size types
# (i.e. will wrap sooner).
#
#PTW32_FLAGS = "-DPTW32_THREAD_ID_REUSE_INCREMENT=0"
#
# ----------------------------------------------------------------------
GC_CFLAGS = $(PTW32_FLAGS)
GCE_CFLAGS = $(PTW32_FLAGS) -mthreads
## Mingw
MAKE ?= make
CFLAGS = $(OPT) $(XOPT) -I. -DHAVE_PTW32_CONFIG_H -Wall
DLL_INLINED_OBJS = \
pthread.o \
version.o
# Agregate modules for inlinability
DLL_OBJS = \
attr.o \
barrier.o \
cancel.o \
cleanup.o \
condvar.o \
create.o \
dll.o \
errno.o \
exit.o \
fork.o \
global.o \
misc.o \
mutex.o \
nonportable.o \
private.o \
rwlock.o \
sched.o \
semaphore.o \
signal.o \
spin.o \
sync.o \
tsd.o \
version.o
# Separate modules for minimum size statically linked images
SMALL_STATIC_OBJS = \
pthread_attr_init.o \
pthread_attr_destroy.o \
pthread_attr_getdetachstate.o \
pthread_attr_setdetachstate.o \
pthread_attr_getstackaddr.o \
pthread_attr_setstackaddr.o \
pthread_attr_getstacksize.o \
pthread_attr_setstacksize.o \
pthread_attr_getscope.o \
pthread_attr_setscope.o \
pthread_attr_setschedpolicy.o \
pthread_attr_getschedpolicy.o \
pthread_attr_setschedparam.o \
pthread_attr_getschedparam.o \
pthread_attr_setinheritsched.o \
pthread_attr_getinheritsched.o \
pthread_barrier_init.o \
pthread_barrier_destroy.o \
pthread_barrier_wait.o \
pthread_barrierattr_init.o \
pthread_barrierattr_destroy.o \
pthread_barrierattr_setpshared.o \
pthread_barrierattr_getpshared.o \
pthread_setcancelstate.o \
pthread_setcanceltype.o \
pthread_testcancel.o \
pthread_cancel.o \
cleanup.o \
pthread_condattr_destroy.o \
pthread_condattr_getpshared.o \
pthread_condattr_init.o \
pthread_condattr_setpshared.o \
pthread_cond_destroy.o \
pthread_cond_init.o \
pthread_cond_signal.o \
pthread_cond_wait.o \
create.o \
dll.o \
autostatic.o \
errno.o \
pthread_exit.o \
fork.o \
global.o \
pthread_mutex_init.o \
pthread_mutex_destroy.o \
pthread_mutexattr_init.o \
pthread_mutexattr_destroy.o \
pthread_mutexattr_getpshared.o \
pthread_mutexattr_setpshared.o \
pthread_mutexattr_settype.o \
pthread_mutexattr_gettype.o \
pthread_mutexattr_setrobust.o \
pthread_mutexattr_getrobust.o \
pthread_mutex_lock.o \
pthread_mutex_timedlock.o \
pthread_mutex_unlock.o \
pthread_mutex_trylock.o \
pthread_mutex_consistent.o \
pthread_mutexattr_setkind_np.o \
pthread_mutexattr_getkind_np.o \
pthread_getw32threadhandle_np.o \
pthread_getunique_np.o \
pthread_delay_np.o \
pthread_num_processors_np.o \
pthread_win32_attach_detach_np.o \
pthread_equal.o \
pthread_getconcurrency.o \
pthread_once.o \
pthread_self.o \
pthread_setconcurrency.o \
pthread_rwlock_init.o \
pthread_rwlock_destroy.o \
pthread_rwlockattr_init.o \
pthread_rwlockattr_destroy.o \
pthread_rwlockattr_getpshared.o \
pthread_rwlockattr_setpshared.o \
pthread_rwlock_rdlock.o \
pthread_rwlock_wrlock.o \
pthread_rwlock_unlock.o \
pthread_rwlock_tryrdlock.o \
pthread_rwlock_trywrlock.o \
pthread_setschedparam.o \
pthread_getschedparam.o \
pthread_timechange_handler_np.o \
ptw32_is_attr.o \
ptw32_cond_check_need_init.o \
ptw32_MCS_lock.o \
ptw32_mutex_check_need_init.o \
ptw32_processInitialize.o \
ptw32_processTerminate.o \
ptw32_threadStart.o \
ptw32_threadDestroy.o \
ptw32_tkAssocCreate.o \
ptw32_tkAssocDestroy.o \
ptw32_callUserDestroyRoutines.o \
ptw32_timespec.o \
ptw32_throw.o \
ptw32_getprocessors.o \
ptw32_calloc.o \
ptw32_new.o \
ptw32_reuse.o \
ptw32_semwait.o \
ptw32_relmillisecs.o \
ptw32_rwlock_check_need_init.o \
sched_get_priority_max.o \
sched_get_priority_min.o \
sched_setscheduler.o \
sched_getscheduler.o \
sched_yield.o \
sem_init.o \
sem_destroy.o \
sem_trywait.o \
sem_timedwait.o \
sem_wait.o \
sem_post.o \
sem_post_multiple.o \
sem_getvalue.o \
sem_open.o \
sem_close.o \
sem_unlink.o \
signal.o \
pthread_kill.o \
ptw32_spinlock_check_need_init.o \
pthread_spin_init.o \
pthread_spin_destroy.o \
pthread_spin_lock.o \
pthread_spin_unlock.o \
pthread_spin_trylock.o \
pthread_detach.o \
pthread_join.o \
pthread_key_create.o \
pthread_key_delete.o \
pthread_setspecific.o \
pthread_getspecific.o \
w32_CancelableWait.o \
version.o
INCL = \
config.h \
implement.h \
semaphore.h \
pthread.h \
need_errno.h
ATTR_SRCS = \
pthread_attr_init.c \
pthread_attr_destroy.c \
pthread_attr_getdetachstate.c \
pthread_attr_setdetachstate.c \
pthread_attr_getstackaddr.c \
pthread_attr_setstackaddr.c \
pthread_attr_getstacksize.c \
pthread_attr_setstacksize.c \
pthread_attr_getscope.c \
pthread_attr_setscope.c
BARRIER_SRCS = \
pthread_barrier_init.c \
pthread_barrier_destroy.c \
pthread_barrier_wait.c \
pthread_barrierattr_init.c \
pthread_barrierattr_destroy.c \
pthread_barrierattr_setpshared.c \
pthread_barrierattr_getpshared.c
CANCEL_SRCS = \
pthread_setcancelstate.c \
pthread_setcanceltype.c \
pthread_testcancel.c \
pthread_cancel.c
CONDVAR_SRCS = \
ptw32_cond_check_need_init.c \
pthread_condattr_destroy.c \
pthread_condattr_getpshared.c \
pthread_condattr_init.c \
pthread_condattr_setpshared.c \
pthread_cond_destroy.c \
pthread_cond_init.c \
pthread_cond_signal.c \
pthread_cond_wait.c
EXIT_SRCS = \
pthread_exit.c
MISC_SRCS = \
pthread_equal.c \
pthread_getconcurrency.c \
pthread_kill.c \
pthread_once.c \
pthread_self.c \
pthread_setconcurrency.c \
ptw32_calloc.c \
ptw32_MCS_lock.c \
ptw32_new.c \
ptw32_reuse.c \
w32_CancelableWait.c
MUTEX_SRCS = \
ptw32_mutex_check_need_init.c \
pthread_mutex_init.c \
pthread_mutex_destroy.c \
pthread_mutexattr_init.c \
pthread_mutexattr_destroy.c \
pthread_mutexattr_getpshared.c \
pthread_mutexattr_setpshared.c \
pthread_mutexattr_settype.c \
pthread_mutexattr_gettype.c \
pthread_mutexattr_setrobust.c \
pthread_mutexattr_getrobust.c \
pthread_mutex_lock.c \
pthread_mutex_timedlock.c \
pthread_mutex_unlock.c \
pthread_mutex_trylock.c \
pthread_mutex_consistent.c
NONPORTABLE_SRCS = \
pthread_mutexattr_setkind_np.c \
pthread_mutexattr_getkind_np.c \
pthread_getw32threadhandle_np.c \
pthread_getunique_np.c \
pthread_delay_np.c \
pthread_num_processors_np.c \
pthread_win32_attach_detach_np.c \
pthread_timechange_handler_np.c
PRIVATE_SRCS = \
ptw32_is_attr.c \
ptw32_processInitialize.c \
ptw32_processTerminate.c \
ptw32_threadStart.c \
ptw32_threadDestroy.c \
ptw32_tkAssocCreate.c \
ptw32_tkAssocDestroy.c \
ptw32_callUserDestroyRoutines.c \
ptw32_semwait.c \
ptw32_relmillisecs.c \
ptw32_timespec.c \
ptw32_throw.c \
ptw32_getprocessors.c
RWLOCK_SRCS = \
ptw32_rwlock_check_need_init.c \
ptw32_rwlock_cancelwrwait.c \
pthread_rwlock_init.c \
pthread_rwlock_destroy.c \
pthread_rwlockattr_init.c \
pthread_rwlockattr_destroy.c \
pthread_rwlockattr_getpshared.c \
pthread_rwlockattr_setpshared.c \
pthread_rwlock_rdlock.c \
pthread_rwlock_timedrdlock.c \
pthread_rwlock_wrlock.c \
pthread_rwlock_timedwrlock.c \
pthread_rwlock_unlock.c \
pthread_rwlock_tryrdlock.c \
pthread_rwlock_trywrlock.c
SCHED_SRCS = \
pthread_attr_setschedpolicy.c \
pthread_attr_getschedpolicy.c \
pthread_attr_setschedparam.c \
pthread_attr_getschedparam.c \
pthread_attr_setinheritsched.c \
pthread_attr_getinheritsched.c \
pthread_setschedparam.c \
pthread_getschedparam.c \
sched_get_priority_max.c \
sched_get_priority_min.c \
sched_setscheduler.c \
sched_getscheduler.c \
sched_yield.c
SEMAPHORE_SRCS = \
sem_init.c \
sem_destroy.c \
sem_trywait.c \
sem_timedwait.c \
sem_wait.c \
sem_post.c \
sem_post_multiple.c \
sem_getvalue.c \
sem_open.c \
sem_close.c \
sem_unlink.c
SPIN_SRCS = \
ptw32_spinlock_check_need_init.c \
pthread_spin_init.c \
pthread_spin_destroy.c \
pthread_spin_lock.c \
pthread_spin_unlock.c \
pthread_spin_trylock.c
SYNC_SRCS = \
pthread_detach.c \
pthread_join.c
TSD_SRCS = \
pthread_key_create.c \
pthread_key_delete.c \
pthread_setspecific.c \
pthread_getspecific.c
GCE_DLL = pthreadGCE$(DLL_VER).dll
GCED_DLL= pthreadGCE$(DLL_VERD).dll
GCE_LIB = libpthreadGCE$(DLL_VER).a
GCED_LIB= libpthreadGCE$(DLL_VERD).a
GCE_INLINED_STAMP = pthreadGCE$(DLL_VER).stamp
GCED_INLINED_STAMP = pthreadGCE$(DLL_VERD).stamp
GCE_STATIC_STAMP = libpthreadGCE$(DLL_VER).stamp
GCED_STATIC_STAMP = libpthreadGCE$(DLL_VERD).stamp
GC_DLL = pthreadGC$(DLL_VER).dll
GCD_DLL = pthreadGC$(DLL_VERD).dll
GC_LIB = libpthreadGC$(DLL_VER).a
GCD_LIB = libpthreadGC$(DLL_VERD).a
GC_INLINED_STAMP = pthreadGC$(DLL_VER).stamp
GCD_INLINED_STAMP = pthreadGC$(DLL_VERD).stamp
GC_STATIC_STAMP = libpthreadGC$(DLL_VER).stamp
GCD_STATIC_STAMP = libpthreadGC$(DLL_VERD).stamp
PTHREAD_DEF = pthread.def
help:
@ echo "Run one of the following command lines:"
@ echo "make clean GC (to build the GNU C dll with C cleanup code)"
@ echo "make clean GCE (to build the GNU C dll with C++ exception handling)"
@ echo "make clean GC-inlined (to build the GNU C inlined dll with C cleanup code)"
@ echo "make clean GCE-inlined (to build the GNU C inlined dll with C++ exception handling)"
@ echo "make clean GC-static (to build the GNU C inlined static lib with C cleanup code)"
@ echo "make clean GC-debug (to build the GNU C debug dll with C cleanup code)"
@ echo "make clean GCE-debug (to build the GNU C debug dll with C++ exception handling)"
@ echo "make clean GC-inlined-debug (to build the GNU C inlined debug dll with C cleanup code)"
@ echo "make clean GCE-inlined-debug (to build the GNU C inlined debug dll with C++ exception handling)"
@ echo "make clean GC-static-debug (to build the GNU C inlined static debug lib with C cleanup code)"
all:
@ $(MAKE) clean GCE
@ $(MAKE) clean GC
GC:
$(MAKE) CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_OBJS)" $(GC_DLL)
GC-debug:
$(MAKE) CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_DLL)
GCE:
$(MAKE) CC=$(CXX) CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_OBJS)" $(GCE_DLL)
GCE-debug:
$(MAKE) CC=$(CXX) CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_CXX -g -O0" $(GCED_DLL)
GC-inlined:
$(MAKE) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GC_INLINED_STAMP)
GC-inlined-debug:
$(MAKE) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_INLINED_STAMP)
GCE-inlined:
$(MAKE) CC=$(CXX) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GCE_INLINED_STAMP)
GCE-inlined-debug:
$(MAKE) CC=$(CXX) XOPT="-DPTW32_BUILD_INLINED" CLEANUP=-D__CLEANUP_CXX XC_FLAGS="$(GCE_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_CXX -g -O0" $(GCED_INLINED_STAMP)
GC-static:
$(MAKE) XOPT="-DPTW32_BUILD_INLINED -DPTW32_STATIC_LIB" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" $(GC_STATIC_STAMP)
GC-static-debug:
$(MAKE) XOPT="-DPTW32_BUILD_INLINED -DPTW32_STATIC_LIB" CLEANUP=-D__CLEANUP_C XC_FLAGS="$(GC_CFLAGS)" OBJ="$(DLL_INLINED_OBJS)" DLL_VER=$(DLL_VERD) OPT="-D__CLEANUP_C -g -O0" $(GCD_STATIC_STAMP)
tests:
@ cd tests
@ $(MAKE) auto
%.pre: %.c
$(CC) -E -o $@ $(CFLAGS) $^
%.s: %.c
$(CC) -c $(CFLAGS) -DPTW32_BUILD_INLINED -Wa,-ahl $^ > $@
%.o: %.rc
$(RC) $(RCFLAGS) $(CLEANUP) -o $@ -i $<
.SUFFIXES: .dll .rc .c .o
.c.o:; $(CC) -c -o $@ $(CFLAGS) $(XC_FLAGS) $<
$(GC_DLL) $(GCD_DLL): $(DLL_OBJS)
$(CC) $(OPT) -shared -o $(GC_DLL) $(DLL_OBJS) $(LFLAGS)
$(DLLTOOL) -z pthread.def $(DLL_OBJS)
$(DLLTOOL) -k --dllname $@ --output-lib $(GC_LIB) --def $(PTHREAD_DEF)
$(GCE_DLL): $(DLL_OBJS)
$(CC) $(OPT) -mthreads -shared -o $(GCE_DLL) $(DLL_OBJS) $(LFLAGS)
$(DLLTOOL) -z pthread.def $(DLL_OBJS)
$(DLLTOOL) -k --dllname $@ --output-lib $(GCE_LIB) --def $(PTHREAD_DEF)
$(GC_INLINED_STAMP) $(GCD_INLINED_STAMP): $(DLL_INLINED_OBJS)
$(CC) $(OPT) $(XOPT) -shared -o $(GC_DLL) $(DLL_INLINED_OBJS) $(LFLAGS)
$(DLLTOOL) -z pthread.def $(DLL_INLINED_OBJS)
$(DLLTOOL) -k --dllname $(GC_DLL) --output-lib $(GC_LIB) --def $(PTHREAD_DEF)
echo touched > $(GC_INLINED_STAMP)
$(GCE_INLINED_STAMP) $(GCED_INLINED_STAMP): $(DLL_INLINED_OBJS)
$(CC) $(OPT) $(XOPT) -mthreads -shared -o $(GCE_DLL) $(DLL_INLINED_OBJS) $(LFLAGS)
$(DLLTOOL) -z pthread.def $(DLL_INLINED_OBJS)
$(DLLTOOL) -k --dllname $(GCE_DLL) --output-lib $(GCE_LIB) --def $(PTHREAD_DEF)
echo touched > $(GCE_INLINED_STAMP)
$(GC_STATIC_STAMP) $(GCD_STATIC_STAMP): $(DLL_INLINED_OBJS)
$(RM) $(GC_LIB)
$(AR) -rv $(GC_LIB) $(DLL_INLINED_OBJS)
$(RANLIB) $(GC_LIB)
echo touched > $(GC_STATIC_STAMP)
clean:
-$(RM) *~
-$(RM) *.i
-$(RM) *.s
-$(RM) *.o
-$(RM) *.obj
-$(RM) *.exe
-$(RM) $(PTHREAD_DEF)
realclean: clean
-$(RM) $(GC_LIB)
-$(RM) $(GCE_LIB)
-$(RM) $(GC_DLL)
-$(RM) $(GCE_DLL)
-$(RM) $(GC_INLINED_STAMP)
-$(RM) $(GCE_INLINED_STAMP)
-$(RM) $(GC_STATIC_STAMP)
-$(RM) $(GCD_LIB)
-$(RM) $(GCED_LIB)
-$(RM) $(GCD_DLL)
-$(RM) $(GCED_DLL)
-$(RM) $(GCD_INLINED_STAMP)
-$(RM) $(GCED_INLINED_STAMP)
-$(RM) $(GCD_STATIC_STAMP)
attr.o: attr.c $(ATTR_SRCS) $(INCL)
barrier.o: barrier.c $(BARRIER_SRCS) $(INCL)
cancel.o: cancel.c $(CANCEL_SRCS) $(INCL)
condvar.o: condvar.c $(CONDVAR_SRCS) $(INCL)
exit.o: exit.c $(EXIT_SRCS) $(INCL)
misc.o: misc.c $(MISC_SRCS) $(INCL)
mutex.o: mutex.c $(MUTEX_SRCS) $(INCL)
nonportable.o: nonportable.c $(NONPORTABLE_SRCS) $(INCL)
private.o: private.c $(PRIVATE_SRCS) $(INCL)
rwlock.o: rwlock.c $(RWLOCK_SRCS) $(INCL)
sched.o: sched.c $(SCHED_SRCS) $(INCL)
semaphore.o: semaphore.c $(SEMAPHORE_SRCS) $(INCL)
spin.o: spin.c $(SPIN_SRCS) $(INCL)
sync.o: sync.c $(SYNC_SRCS) $(INCL)
tsd.o: tsd.c $(TSD_SRCS) $(INCL)
version.o: version.rc $(INCL)

4
3rdparty/pthreads4w/MAINTAINERS vendored
View File

@ -1,4 +0,0 @@
CVS Repository maintainers
Ross Johnson rpj@ise.canberra.edu.au
Ben Elliston bje@cygnus.com

514
3rdparty/pthreads4w/Makefile vendored
View File

@ -1,514 +0,0 @@
# This makefile is compatible with MS nmake and can be used as a
# replacement for buildlib.bat. I've changed the target from an ordinary dll
# (/LD) to a debugging dll (/LDd).
#
# The variables $DLLDEST and $LIBDEST hold the destination directories for the
# dll and the lib, respectively. Probably all that needs to change is $DEVROOT.
# DLL_VER:
# See pthread.h and README - This number is computed as 'current - age'
DLL_VER = 2
DLL_VERD= $(DLL_VER)d
DEVROOT = C:\pthreads
DLLDEST = $(DEVROOT)\dll
LIBDEST = $(DEVROOT)\lib
HDRDEST = $(DEVROOT)\include
DLLS = pthreadVCE$(DLL_VER).dll pthreadVSE$(DLL_VER).dll pthreadVC$(DLL_VER).dll \
pthreadVCE$(DLL_VERD).dll pthreadVSE$(DLL_VERD).dll pthreadVC$(DLL_VERD).dll
INLINED_STAMPS = pthreadVCE$(DLL_VER).stamp pthreadVSE$(DLL_VER).stamp pthreadVC$(DLL_VER).stamp \
pthreadVCE$(DLL_VERD).stamp pthreadVSE$(DLL_VERD).stamp pthreadVC$(DLL_VERD).stamp
STATIC_STAMPS = pthreadVCE$(DLL_VER).static pthreadVSE$(DLL_VER).static pthreadVC$(DLL_VER).static \
pthreadVCE$(DLL_VERD).static pthreadVSE$(DLL_VERD).static pthreadVC$(DLL_VERD).static
CC = cl
CPPFLAGS = /I. /DHAVE_PTW32_CONFIG_H
XCFLAGS = /W3 /MD /nologo
CFLAGS = /O2 /Ob2 $(XCFLAGS)
CFLAGSD = /Z7 $(XCFLAGS)
# Uncomment this if config.h defines RETAIN_WSALASTERROR
#XLIBS = wsock32.lib
# Default cleanup style
CLEANUP = __CLEANUP_C
# C++ Exceptions
VCEFLAGS = /EHsc /TP $(CPPFLAGS) $(CFLAGS)
VCEFLAGSD = /EHsc /TP $(CPPFLAGS) $(CFLAGSD)
#Structured Exceptions
VSEFLAGS = $(CPPFLAGS) $(CFLAGS)
VSEFLAGSD = $(CPPFLAGS) $(CFLAGSD)
#C cleanup code
VCFLAGS = $(CPPFLAGS) $(CFLAGS)
VCFLAGSD = $(CPPFLAGS) $(CFLAGSD)
DLL_INLINED_OBJS = \
pthread.obj \
version.res
# Aggregate modules for inlinability
DLL_OBJS = \
attr.obj \
barrier.obj \
cancel.obj \
cleanup.obj \
condvar.obj \
create.obj \
dll.obj \
autostatic.obj \
errno.obj \
exit.obj \
fork.obj \
global.obj \
misc.obj \
mutex.obj \
nonportable.obj \
private.obj \
rwlock.obj \
sched.obj \
semaphore.obj \
signal.obj \
spin.obj \
sync.obj \
tsd.obj \
version.res
# Separate modules for minimising the size of statically linked images
SMALL_STATIC_OBJS = \
pthread_attr_init.obj \
pthread_attr_destroy.obj \
pthread_attr_getdetachstate.obj \
pthread_attr_setdetachstate.obj \
pthread_attr_getstackaddr.obj \
pthread_attr_setstackaddr.obj \
pthread_attr_getstacksize.obj \
pthread_attr_setstacksize.obj \
pthread_attr_getscope.obj \
pthread_attr_setscope.obj \
pthread_attr_setschedpolicy.obj \
pthread_attr_getschedpolicy.obj \
pthread_attr_setschedparam.obj \
pthread_attr_getschedparam.obj \
pthread_attr_setinheritsched.obj \
pthread_attr_getinheritsched.obj \
pthread_barrier_init.obj \
pthread_barrier_destroy.obj \
pthread_barrier_wait.obj \
pthread_barrierattr_init.obj \
pthread_barrierattr_destroy.obj \
pthread_barrierattr_setpshared.obj \
pthread_barrierattr_getpshared.obj \
pthread_setcancelstate.obj \
pthread_setcanceltype.obj \
pthread_testcancel.obj \
pthread_cancel.obj \
cleanup.obj \
pthread_condattr_destroy.obj \
pthread_condattr_getpshared.obj \
pthread_condattr_init.obj \
pthread_condattr_setpshared.obj \
pthread_cond_destroy.obj \
pthread_cond_init.obj \
pthread_cond_signal.obj \
pthread_cond_wait.obj \
create.obj \
dll.obj \
autostatic.obj \
errno.obj \
pthread_exit.obj \
fork.obj \
global.obj \
pthread_mutex_init.obj \
pthread_mutex_destroy.obj \
pthread_mutexattr_init.obj \
pthread_mutexattr_destroy.obj \
pthread_mutexattr_getpshared.obj \
pthread_mutexattr_setpshared.obj \
pthread_mutexattr_settype.obj \
pthread_mutexattr_gettype.obj \
pthread_mutexattr_setrobust.obj \
pthread_mutexattr_getrobust.obj \
pthread_mutex_lock.obj \
pthread_mutex_timedlock.obj \
pthread_mutex_unlock.obj \
pthread_mutex_trylock.obj \
pthread_mutex_consistent.obj \
pthread_mutexattr_setkind_np.obj \
pthread_mutexattr_getkind_np.obj \
pthread_getw32threadhandle_np.obj \
pthread_getunique_np.obj \
pthread_delay_np.obj \
pthread_num_processors_np.obj \
pthread_win32_attach_detach_np.obj \
pthread_equal.obj \
pthread_getconcurrency.obj \
pthread_once.obj \
pthread_self.obj \
pthread_setconcurrency.obj \
pthread_rwlock_init.obj \
pthread_rwlock_destroy.obj \
pthread_rwlockattr_init.obj \
pthread_rwlockattr_destroy.obj \
pthread_rwlockattr_getpshared.obj \
pthread_rwlockattr_setpshared.obj \
pthread_rwlock_rdlock.obj \
pthread_rwlock_wrlock.obj \
pthread_rwlock_unlock.obj \
pthread_rwlock_tryrdlock.obj \
pthread_rwlock_trywrlock.obj \
pthread_setschedparam.obj \
pthread_getschedparam.obj \
pthread_timechange_handler_np.obj \
ptw32_is_attr.obj \
ptw32_processInitialize.obj \
ptw32_processTerminate.obj \
ptw32_threadStart.obj \
ptw32_threadDestroy.obj \
ptw32_tkAssocCreate.obj \
ptw32_tkAssocDestroy.obj \
ptw32_callUserDestroyRoutines.obj \
ptw32_timespec.obj \
ptw32_throw.obj \
ptw32_getprocessors.obj \
ptw32_calloc.obj \
ptw32_new.obj \
ptw32_reuse.obj \
ptw32_rwlock_check_need_init.obj \
ptw32_cond_check_need_init.obj \
ptw32_mutex_check_need_init.obj \
ptw32_semwait.obj \
ptw32_relmillisecs.obj \
ptw32_MCS_lock.obj \
sched_get_priority_max.obj \
sched_get_priority_min.obj \
sched_setscheduler.obj \
sched_getscheduler.obj \
sched_yield.obj \
sem_init.obj \
sem_destroy.obj \
sem_trywait.obj \
sem_timedwait.obj \
sem_wait.obj \
sem_post.obj \
sem_post_multiple.obj \
sem_getvalue.obj \
sem_open.obj \
sem_close.obj \
sem_unlink.obj \
signal.obj \
pthread_kill.obj \
ptw32_spinlock_check_need_init.obj \
pthread_spin_init.obj \
pthread_spin_destroy.obj \
pthread_spin_lock.obj \
pthread_spin_unlock.obj \
pthread_spin_trylock.obj \
pthread_detach.obj \
pthread_join.obj \
pthread_key_create.obj \
pthread_key_delete.obj \
pthread_setspecific.obj \
pthread_getspecific.obj \
w32_CancelableWait.obj \
version.res
INCL = config.h implement.h semaphore.h pthread.h need_errno.h
ATTR_SRCS = \
pthread_attr_init.c \
pthread_attr_destroy.c \
pthread_attr_getdetachstate.c \
pthread_attr_setdetachstate.c \
pthread_attr_getstackaddr.c \
pthread_attr_setstackaddr.c \
pthread_attr_getstacksize.c \
pthread_attr_setstacksize.c \
pthread_attr_getscope.c \
pthread_attr_setscope.c
BARRIER_SRCS = \
pthread_barrier_init.c \
pthread_barrier_destroy.c \
pthread_barrier_wait.c \
pthread_barrierattr_init.c \
pthread_barrierattr_destroy.c \
pthread_barrierattr_setpshared.c \
pthread_barrierattr_getpshared.c
CANCEL_SRCS = \
pthread_setcancelstate.c \
pthread_setcanceltype.c \
pthread_testcancel.c \
pthread_cancel.c
CONDVAR_SRCS = \
ptw32_cond_check_need_init.c \
pthread_condattr_destroy.c \
pthread_condattr_getpshared.c \
pthread_condattr_init.c \
pthread_condattr_setpshared.c \
pthread_cond_destroy.c \
pthread_cond_init.c \
pthread_cond_signal.c \
pthread_cond_wait.c
EXIT_SRCS = \
pthread_exit.c
MISC_SRCS = \
pthread_equal.c \
pthread_getconcurrency.c \
pthread_kill.c \
pthread_once.c \
pthread_self.c \
pthread_setconcurrency.c \
ptw32_calloc.c \
ptw32_MCS_lock.c \
ptw32_new.c \
ptw32_reuse.c \
ptw32_relmillisecs.c \
w32_CancelableWait.c
MUTEX_SRCS = \
ptw32_mutex_check_need_init.c \
pthread_mutex_init.c \
pthread_mutex_destroy.c \
pthread_mutexattr_init.c \
pthread_mutexattr_destroy.c \
pthread_mutexattr_getpshared.c \
pthread_mutexattr_setpshared.c \
pthread_mutexattr_settype.c \
pthread_mutexattr_gettype.c \
pthread_mutexattr_setrobust.c \
pthread_mutexattr_getrobust.c \
pthread_mutex_lock.c \
pthread_mutex_timedlock.c \
pthread_mutex_unlock.c \
pthread_mutex_trylock.c \
pthread_mutex_consistent.c
NONPORTABLE_SRCS = \
pthread_mutexattr_setkind_np.c \
pthread_mutexattr_getkind_np.c \
pthread_getw32threadhandle_np.c \
pthread_getunique_np.c \
pthread_delay_np.c \
pthread_num_processors_np.c \
pthread_win32_attach_detach_np.c \
pthread_timechange_handler_np.c
PRIVATE_SRCS = \
ptw32_is_attr.c \
ptw32_processInitialize.c \
ptw32_processTerminate.c \
ptw32_threadStart.c \
ptw32_threadDestroy.c \
ptw32_tkAssocCreate.c \
ptw32_tkAssocDestroy.c \
ptw32_callUserDestroyRoutines.c \
ptw32_semwait.c \
ptw32_timespec.c \
ptw32_throw.c \
ptw32_getprocessors.c
RWLOCK_SRCS = \
ptw32_rwlock_check_need_init.c \
ptw32_rwlock_cancelwrwait.c \
pthread_rwlock_init.c \
pthread_rwlock_destroy.c \
pthread_rwlockattr_init.c \
pthread_rwlockattr_destroy.c \
pthread_rwlockattr_getpshared.c \
pthread_rwlockattr_setpshared.c \
pthread_rwlock_rdlock.c \
pthread_rwlock_timedrdlock.c \
pthread_rwlock_wrlock.c \
pthread_rwlock_timedwrlock.c \
pthread_rwlock_unlock.c \
pthread_rwlock_tryrdlock.c \
pthread_rwlock_trywrlock.c
SCHED_SRCS = \
pthread_attr_setschedpolicy.c \
pthread_attr_getschedpolicy.c \
pthread_attr_setschedparam.c \
pthread_attr_getschedparam.c \
pthread_attr_setinheritsched.c \
pthread_attr_getinheritsched.c \
pthread_setschedparam.c \
pthread_getschedparam.c \
sched_get_priority_max.c \
sched_get_priority_min.c \
sched_setscheduler.c \
sched_getscheduler.c \
sched_yield.c
SEMAPHORE_SRCS = \
sem_init.c \
sem_destroy.c \
sem_trywait.c \
sem_timedwait.c \
sem_wait.c \
sem_post.c \
sem_post_multiple.c \
sem_getvalue.c \
sem_open.c \
sem_close.c \
sem_unlink.c
SPIN_SRCS = \
ptw32_spinlock_check_need_init.c \
pthread_spin_init.c \
pthread_spin_destroy.c \
pthread_spin_lock.c \
pthread_spin_unlock.c \
pthread_spin_trylock.c
SYNC_SRCS = \
pthread_detach.c \
pthread_join.c
TSD_SRCS = \
pthread_key_create.c \
pthread_key_delete.c \
pthread_setspecific.c \
pthread_getspecific.c
help:
@ echo Run one of the following command lines:
@ echo nmake clean VCE (to build the MSVC dll with C++ exception handling)
@ echo nmake clean VSE (to build the MSVC dll with structured exception handling)
@ echo nmake clean VC (to build the MSVC dll with C cleanup code)
@ echo nmake clean VCE-inlined (to build the MSVC inlined dll with C++ exception handling)
@ echo nmake clean VSE-inlined (to build the MSVC inlined dll with structured exception handling)
@ echo nmake clean VC-inlined (to build the MSVC inlined dll with C cleanup code)
@ echo nmake clean VC-static (to build the MSVC static lib with C cleanup code)
@ echo nmake clean VCE-debug (to build the debug MSVC dll with C++ exception handling)
@ echo nmake clean VSE-debug (to build the debug MSVC dll with structured exception handling)
@ echo nmake clean VC-debug (to build the debug MSVC dll with C cleanup code)
@ echo nmake clean VCE-inlined-debug (to build the debug MSVC inlined dll with C++ exception handling)
@ echo nmake clean VSE-inlined-debug (to build the debug MSVC inlined dll with structured exception handling)
@ echo nmake clean VC-inlined-debug (to build the debug MSVC inlined dll with C cleanup code)
@ echo nmake clean VC-static-debug (to build the debug MSVC static lib with C cleanup code)
all:
@ $(MAKE) /E clean VCE-inlined
@ $(MAKE) /E clean VSE-inlined
@ $(MAKE) /E clean VC-inlined
@ $(MAKE) /E clean VCE-inlined-debug
@ $(MAKE) /E clean VSE-inlined-debug
@ $(MAKE) /E clean VC-inlined-debug
VCE:
@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGS)" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VER).dll
VCE-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGSD)" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VERD).dll
VSE:
@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGS)" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VER).dll
VSE-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGSD)" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VERD).dll
VC:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS)" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).dll
VC-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD)" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).dll
#
# The so-called inlined DLL is just a single translation unit with
# inlining optimisation turned on.
#
VCE-inlined:
@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGS) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VER).stamp
VCE-inlined-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VCEFLAGSD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_CXX pthreadVCE$(DLL_VERD).stamp
VSE-inlined:
@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGS) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VER).stamp
VSE-inlined-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VSEFLAGSD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_SEH pthreadVSE$(DLL_VERD).stamp
VC-inlined:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).stamp
VC-inlined-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD) /DPTW32_BUILD_INLINED" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).stamp
VC-static:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGS) /DPTW32_BUILD_INLINED /DPTW32_STATIC_LIB" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VER).static
VC-static-debug:
@ $(MAKE) /E /nologo EHFLAGS="$(VCFLAGSD) /DPTW32_BUILD_INLINED /DPTW32_STATIC_LIB" CLEANUP=__CLEANUP_C pthreadVC$(DLL_VERD).static
realclean: clean
if exist pthread*.dll del pthread*.dll
if exist pthread*.lib del pthread*.lib
if exist *.manifest del *.manifest
if exist *.stamp del *.stamp
clean:
if exist *.obj del *.obj
if exist *.def del *.def
if exist *.ilk del *.ilk
if exist *.pdb del *.pdb
if exist *.exp del *.exp
if exist *.map del *.map
if exist *.o del *.o
if exist *.i del *.i
if exist *.res del *.res
install:
copy pthread*.dll $(DLLDEST)
copy pthread*.lib $(LIBDEST)
copy pthread.h $(HDRDEST)
copy sched.h $(HDRDEST)
copy semaphore.h $(HDRDEST)
$(DLLS): $(DLL_OBJS)
$(CC) /LDd /Zi /nologo $(DLL_OBJS) /link /implib:$*.lib $(XLIBS) /out:$@
$(INLINED_STAMPS): $(DLL_INLINED_OBJS)
$(CC) /LDd /Zi /nologo $(DLL_INLINED_OBJS) /link /implib:$*.lib $(XLIBS) /out:$*.dll
$(STATIC_STAMPS): $(DLL_INLINED_OBJS)
if exist $*.lib del $*.lib
lib $(DLL_INLINED_OBJS) /out:$*.lib
.c.obj:
$(CC) $(EHFLAGS) /D$(CLEANUP) -c $<
# TARGET_CPU is an environment variable set by Visual Studio Command Prompt
# as provided by the SDK
.rc.res:
rc /dPTW32_ARCH$(TARGET_CPU) /dPTW32_RC_MSC /d$(CLEANUP) $<
.c.i:
$(CC) /P /O2 /Ob1 $(VCFLAGS) $<
attr.obj: attr.c $(ATTR_SRCS) $(INCL)
barrier.obj: barrier.c $(BARRIER_SRCS) $(INCL)
cancel.obj: cancel.c $(CANCEL_SRCS) $(INCL)
condvar.obj: condvar.c $(CONDVAR_SRCS) $(INCL)
exit.obj: exit.c $(EXIT_SRCS) $(INCL)
misc.obj: misc.c $(MISC_SRCS) $(INCL)
mutex.obj: mutex.c $(MUTEX_SRCS) $(INCL)
nonportable.obj: nonportable.c $(NONPORTABLE_SRCS) $(INCL)
private.obj: private.c $(PRIVATE_SRCS) $(INCL)
rwlock.obj: rwlock.c $(RWLOCK_SRCS) $(INCL)
sched.obj: sched.c $(SCHED_SRCS) $(INCL)
semaphore.obj: semaphore.c $(SEMAPHORE_SRCS) $(INCL)
spin.obj: spin.c $(SPIN_SRCS) $(INCL)
sync.obj: sync.c $(SYNC_SRCS) $(INCL)
tsd.obj: tsd.c $(TSD_SRCS) $(INCL)
version.res: version.rc $(INCL)

1241
3rdparty/pthreads4w/NEWS vendored
View File

File diff suppressed because it is too large Load Diff

24
3rdparty/pthreads4w/Nmakefile vendored
View File

@ -1,24 +0,0 @@
/*
* nmake file for uwin pthread library
*/
VERSION = -
CCFLAGS = -V -g $(CC.DLL)
HAVE_PTW32_CONFIG_H == 1
_MT == 1
_timeb == timeb
_ftime == ftime
_errno == _ast_errno
$(INCLUDEDIR) :INSTALLDIR: pthread.h sched.h
pthread $(VERSION) :LIBRARY: attr.c barrier.c cancel.c cleanup.c condvar.c \
create.c dll.c exit.c fork.c global.c misc.c mutex.c private.c \
rwlock.c sched.c semaphore.c spin.c sync.c tsd.c nonportable.c
:: ANNOUNCE CONTRIBUTORS COPYING.LIB ChangeLog FAQ GNUmakefile MAINTAINERS \
Makefile Makefile.in Makefile.vc NEWS PROGRESS README README.WinCE \
TODO WinCE-PORT install-sh errno.c tests tests.mk acconfig.h \
config.guess config.h.in config.sub configure configure.in signal.c \
README.CV README.NONPORTABLE pthread.dsp pthread.dsw

260
3rdparty/pthreads4w/Nmakefile.tests vendored
View File

@ -1,260 +0,0 @@
/* for running tests */
CCFLAGS = -g
_MT == 1
_timeb == timeb
_ftime == ftime
.SOURCE: tests
/*
:PACKAGE: pthread
*/
set keepgoing
":test:" : .MAKE .OPERATOR
local I
$(<:D:B:S=.pass) : .IMPLICIT $(>:D:B:S=.pass)
for I $(<) $(>)
$(I:D:B:S=.pass) : .VIRTUAL .FORCE $(I)
$(>)
end
sizes:: sizes.c
loadfree:: loadfree.c
mutex1:: mutex1.c
mutex1e:: mutex1e.c
mutex1n:: mutex1n.c
mutex1r:: mutex1r.c
mutex2:: mutex2.c
mutex2r:: mutex2r.c
mutex2e:: mutex2e.c
exit1:: exit1.c
condvar1:: condvar1.c
condvar1_1:: condvar1_1.c
condvar1_2:: condvar1_2.c
self1:: self1.c
condvar2:: condvar2.c
condvar2_1:: condvar2_1.c
condvar3_1:: condvar3_1.c
condvar3_2:: condvar3_2.c
condvar3_3:: condvar3_3.c
create1.:: create1.c
create2.:: create2.c
cancel1:: cancel1.c
cancel2:: cancel2.c
mutex3:: mutex3.c
mutex3r:: mutex3r.c
mutex3e:: mutex3e.c
mutex4:: mutex4.c
mutex5:: mutex5.c
mutex6:: mutex6.c
mutex6e:: mutex6e.c
mutex6n:: mutex6n.c
mutex6r:: mutex6r.c
mutex7:: mutex7.c
mutex6s:: mutex6s.c
mutex6rs:: mutex6rs.c
mutex6es:: mutex6es.c
mutex7e:: mutex7e.c
mutex7n:: mutex7n.c
mutex7r:: mutex7r.c
mutex8:: mutex8.c
mutex8e:: mutex8e.c
mutex8n:: mutex8n.c
mutex8r:: mutex8r.c
equal1:: equal1.c
exit2:: exit2.c
exit3:: exit3.c
exit4:: exit4.c
exit5:: exit5.c
join0:: join0.c
join1:: join1.c
join2:: join2.c
join3:: join3.c
kill1:: kill1.c
count1:: count1.c
once1:: once1.c
tsd1:: tsd1.c
self2:: self2.c
eyal1:: eyal1.c
condvar3:: condvar3.c
condvar4:: condvar4.c
condvar5:: condvar5.c
condvar6:: condvar6.c
condvar7:: condvar7.c
condvar8:: condvar8.c
condvar9:: condvar9.c
errno1:: errno1.c
reuse1.:: reuse1.c
reuse2.:: reuse2.c
rwlock1:: rwlock1.c
rwlock2:: rwlock2.c
rwlock3:: rwlock3.c
rwlock4:: rwlock4.c
rwlock5:: rwlock5.c
rwlock6:: rwlock6.c
rwlock7:: rwlock7.c
rwlock8:: rwlock8.c
rwlock2_t:: rwlock2_t.c
rwlock3_t:: rwlock3_t.c
rwlock4_t:: rwlock4_t.c
rwlock5_t:: rwlock5_t.c
rwlock6_t:: rwlock6_t.c
rwlock6_t2:: rwlock6_t2.c
semaphore1:: semaphore1.c
semaphore2:: semaphore2.c
semaphore3:: semaphore3.c
context1:: context1.c
cancel3:: cancel3.c
cancel4:: cancel4.c
cancel5:: cancel5.c
cancel6a:: cancel6a.c
cancel6d:: cancel6d.c
cancel7:: cancel7.c
cleanup0:: cleanup0.c
cleanup1:: cleanup1.c
cleanup2:: cleanup2.c
cleanup3:: cleanup3.c
priority1:: priority1.c
priority2:: priority2.c
inherit1:: inherit1.c
spin1:: spin1.c
spin2:: spin2.c
spin3:: spin3.c
spin4:: spin4.c
barrier1:: barrier1.c
barrier2:: barrier2.c
barrier3:: barrier3.c
barrier4:: barrier4.c
barrier5:: barrier5.c
exception1:: exception1.c
exception2:: exception2.c
exception3:: exception3.c
benchtest1:: benchtest1.c
benchtest2:: benchtest2.c
benchtest3:: benchtest3.c
benchtest4:: benchtest4.c
benchtest5:: benchtest5.c
valid1:: valid1.c
valid2:: valid2.c
cancel9:: cancel9.c
sizes: :test: sizes
loadfree: :test:
mutex5 :test: loadfree
mutex1 :test: loadfree
mutex1n :test: loadfree
mutex1r :test: loadfree
mutex1e :test: loadfree
semaphore1 :test: loadfree
semaphore2 :test: loadfree
semaphore3 :test: loadfree
mutex2 :test: loadfree
mutex2r :test: loadfree
mutex2e :test: loadfree
exit1 :test: loadfree
condvar1 :test: loadfree
kill1 :test: loadfree
condvar1_1 :test: condvar1
condvar1_2 :test: join2
self1 :test: loadfree
condvar2 :test: condvar1
condvar2_1 :test: condvar2
create1 :test: mutex2
create2 :test: create1
reuse1 :test: create2
reuse2 :test: reuse1
cancel1 :test: create1
cancel2 :test: cancel1
mutex3 :test: create1
mutex3r :test: create1
mutex3e :test: create1
mutex4 :test: mutex3
mutex6 :test: mutex4
mutex6n :test: mutex4
mutex6e :test: mutex4
mutex6r :test: mutex4
mutex6s :test: mutex6
mutex6rs :test: mutex6r
mutex6es :test: mutex6e
mutex7 :test: mutex6
mutex7n :test: mutex6n
mutex7e :test: mutex6e
mutex7r :test: mutex6r
mutex8 :test: mutex7
mutex8n :test: mutex7n
mutex8e :test: mutex7e
mutex8r :test: mutex7r
equal1 :test: create1
exit2 :test: create1
exit3 :test: create1
exit4 :test: kill1
exit5 :test: exit4
join0 :test: create1
join1 :test: create1
join2 :test: create1
join3 :test: join2
count1 :test: join1
once1 :test: create1
tsd1 :test: join1
self2 :test: create1
eyal1 :test: tsd1
condvar3 :test: create1
condvar3_1 :test: condvar3
condvar3_2 :test: condvar3_1
condvar3_3 :test: condvar3_2
condvar4 :test: create1
condvar5 :test: condvar4
condvar6 :test: condvar5
condvar7 :test: condvar6 cleanup1
condvar8 :test: condvar7
condvar9 :test: condvar8
errno1 :test: mutex3
rwlock1 :test: condvar6
rwlock2 :test: rwlock1
rwlock3 :test: rwlock2
rwlock4 :test: rwlock3
rwlock5 :test: rwlock4
rwlock6 :test: rwlock5
rwlock7 :test: rwlock6
rwlock8 :test: rwlock7
rwlock2_t :test: rwlock2
rwlock3_t :test: rwlock2_t
rwlock4_t :test: rwlock3_t
rwlock5_t :test: rwlock4_t
rwlock6_t :test: rwlock5_t
rwlock6_t2 :test: rwlock6_t
context1 :test: cancel2
cancel3 :test: context1
cancel4 :test: cancel3
cancel5 :test: cancel3
cancel6a :test: cancel3
cancel6d :test: cancel3
cancel7 :test: kill1
cleanup0 :test: cancel5
cleanup1 :test: cleanup0
cleanup2 :test: cleanup1
cleanup3 :test: cleanup2
priority1 :test: join1
priority2 :test: priority1
inherit1 :test: join1
spin1 :test:
spin2 :test: spin1.c
spin3 :test: spin2.c
spin4 :test: spin3.c
barrier1 :test:
barrier2 :test: barrier1.c
barrier3 :test: barrier2.c
barrier4 :test: barrier3.c
barrier5 :test: barrier4.c
benchtest1 :test: mutex3
benchtest2 :test: benchtest1
benchtest3 :test: benchtest2
benchtest4 :test: benchtest3
benchtest5 :test: benchtest4
exception1 :test: cancel4
exception2 :test: exception1
exception3 :test: exception2
exit4 :test: exit3
valid1 :test: join1
valid2 :test: valid1
cancel9 :test: cancel8

4
3rdparty/pthreads4w/PROGRESS vendored
View File

@ -1,4 +0,0 @@
Please see the ANNOUNCE file "Level of Standards Conformance"
or the web page:
http://sources.redhat.com/pthreads-win32/conformance.html

601
3rdparty/pthreads4w/README vendored
View File

@ -1,601 +0,0 @@
PTHREADS-WIN32
==============
Pthreads-win32 is free software, distributed under the GNU Lesser
General Public License (LGPL). See the file 'COPYING.LIB' for terms
and conditions. Also see the file 'COPYING' for information
specific to pthreads-win32, copyrights and the LGPL.
What is it?
-----------
Pthreads-win32 is an Open Source Software implementation of the
Threads component of the POSIX 1003.1c 1995 Standard (or later)
for Microsoft's Win32 environment. Some functions from POSIX
1003.1b are also supported including semaphores. Other related
functions include the set of read-write lock functions. The
library also supports some of the functionality of the Open
Group's Single Unix specification, version 2, namely mutex types,
plus some common and pthreads-win32 specific non-portable
routines (see README.NONPORTABLE).
See the file "ANNOUNCE" for more information including standards
conformance details and the list of supported and unsupported
routines.
Prerequisites
-------------
MSVC or GNU C (MinGW32 MSys development kit)
To build from source.
QueueUserAPCEx by Panagiotis E. Hadjidoukas
To support any thread cancelation in C++ library builds or
to support cancelation of blocked threads in any build.
This library is not required otherwise.
For true async cancelation of threads (including blocked threads).
This is a DLL and Windows driver that provides pre-emptive APC
by forcing threads into an alertable state when the APC is queued.
Both the DLL and driver are provided with the pthreads-win32.exe
self-unpacking ZIP, and on the pthreads-win32 FTP site (in source
and pre-built forms). Currently this is a separate LGPL package to
pthreads-win32. See the README in the QueueUserAPCEx folder for
installation instructions.
Pthreads-win32 will automatically detect if the QueueUserAPCEx DLL
QuserEx.DLL is available and whether the driver AlertDrv.sys is
loaded. If it is not available, pthreads-win32 will simulate async
cancelation, which means that it can async cancel only threads that
are runnable. The simulated async cancellation cannot cancel blocked
threads.
[FOR SECURITY] To be found Quserex.dll MUST be installed in the
Windows System Folder. This is not an unreasonable constraint given a
driver must also be installed and loaded at system startup.
Library naming
--------------
Because the library is being built using various exception
handling schemes and compilers - and because the library
may not work reliably if these are mixed in an application,
each different version of the library has it's own name.
Note 1: the incompatibility is really between EH implementations
of the different compilers. It should be possible to use the
standard C version from either compiler with C++ applications
built with a different compiler. If you use an EH version of
the library, then you must use the same compiler for the
application. This is another complication and dependency that
can be avoided by using only the standard C library version.
Note 2: if you use a standard C pthread*.dll with a C++
application, then any functions that you define that are
intended to be called via pthread_cleanup_push() must be
__cdecl.
Note 3: the intention was to also name either the VC or GC
version (it should be arbitrary) as pthread.dll, including
pthread.lib and libpthread.a as appropriate. This is no longer
likely to happen.
Note 4: the compatibility number was added so that applications
can differentiate between binary incompatible versions of the
libs and dlls.
In general:
pthread[VG]{SE,CE,C}[c].dll
pthread[VG]{SE,CE,C}[c].lib
where:
[VG] indicates the compiler
V - MS VC, or
G - GNU C
{SE,CE,C} indicates the exception handling scheme
SE - Structured EH, or
CE - C++ EH, or
C - no exceptions - uses setjmp/longjmp
c - DLL compatibility number indicating ABI and API
compatibility with applications built against
a snapshot with the same compatibility number.
See 'Version numbering' below.
The name may also be suffixed by a 'd' to indicate a debugging version
of the library. E.g. pthreadVC2d.lib. Debugging versions contain
additional information for debugging (symbols etc) and are often not
optimised in any way (compiled with optimisation turned off).
Examples:
pthreadVSE.dll (MSVC/SEH)
pthreadGCE.dll (GNUC/C++ EH)
pthreadGC.dll (GNUC/not dependent on exceptions)
pthreadVC1.dll (MSVC/not dependent on exceptions - not binary
compatible with pthreadVC.dll)
pthreadVC2.dll (MSVC/not dependent on exceptions - not binary
compatible with pthreadVC1.dll or pthreadVC.dll)
The GNU library archive file names have correspondingly changed to:
libpthreadGCEc.a
libpthreadGCc.a
Versioning numbering
--------------------
Version numbering is separate from the snapshot dating system, and
is the canonical version identification system embedded within the
DLL using the Microsoft version resource system. The versioning
system chosen follows the GNU Libtool system. See
http://www.gnu.org/software/libtool/manual.html section 6.2.
See the resource file 'version.rc'.
Microsoft version numbers use 4 integers:
0.0.0.0
Pthreads-win32 uses the first 3 following the Libtool convention.
The fourth is commonly used for the build number, but will be reserved
for future use.
current.revision.age.0
The numbers are changed as follows:
1. If the library source code has changed at all since the last update,
then increment revision (`c:r:a' becomes `c:r+1:a').
2. If any interfaces have been added, removed, or changed since the last
update, increment current, and set revision to 0.
3. If any interfaces have been added since the last public release, then
increment age.
4. If any interfaces have been removed or changed since the last public
release, then set age to 0.
DLL compatibility numbering is an attempt to ensure that applications
always load a compatible pthreads-win32 DLL by using a DLL naming system
that is consistent with the version numbering system. It also allows
older and newer DLLs to coexist in the same filesystem so that older
applications can continue to be used. For pre .NET Windows systems,
this inevitably requires incompatible versions of the same DLLs to have
different names.
Pthreads-win32 has adopted the Cygwin convention of appending a single
integer number to the DLL name. The number used is based on the library
version number and is computed as 'current' - 'age'.
(See http://home.att.net/~perlspinr/libversioning.html for a nicely
detailed explanation.)
Using this method, DLL name/s will only change when the DLL's
backwards compatibility changes. Note that the addition of new
'interfaces' will not of itself change the DLL's compatibility for older
applications.
Which of the several dll versions to use?
-----------------------------------------
or,
---
What are all these pthread*.dll and pthread*.lib files?
-------------------------------------------------------
Simple, use either pthreadGCv.* if you use GCC, or pthreadVCv.* if you
use MSVC - where 'v' is the DLL versioning (compatibility) number.
Otherwise, you need to choose carefully and know WHY.
The most important choice you need to make is whether to use a
version that uses exceptions internally, or not. There are versions
of the library that use exceptions as part of the thread
cancelation and exit implementation. The default version uses
setjmp/longjmp.
There is some contension amongst POSIX threads experts as
to how POSIX threads cancelation and exit should work
with languages that use exceptions, e.g. C++ and even C
(Microsoft's Structured Exceptions).
The issue is: should cancelation of a thread in, say,
a C++ application cause object destructors and C++ exception
handlers to be invoked as the stack unwinds during thread
exit, or not?
There seems to be more opinion in favour of using the
standard C version of the library (no EH) with C++ applications
for the reason that this appears to be the assumption commercial
pthreads implementations make. Therefore, if you use an EH version
of pthreads-win32 then you may be under the illusion that
your application will be portable, when in fact it is likely to
behave differently when linked with other pthreads libraries.
Now you may be asking: then why have you kept the EH versions of
the library?
There are a couple of reasons:
- there is division amongst the experts and so the code may
be needed in the future. Yes, it's in the repository and we
can get it out anytime in the future, but it would be difficult
to find.
- pthreads-win32 is one of the few implementations, and possibly
the only freely available one, that has EH versions. It may be
useful to people who want to play with or study application
behaviour under these conditions.
Notes:
[If you use either pthreadVCE or pthreadGCE]
1. [See also the discussion in the FAQ file - Q2, Q4, and Q5]
If your application contains catch(...) blocks in your POSIX
threads then you will need to replace the "catch(...)" with the macro
"PtW32Catch", eg.
#ifdef PtW32Catch
PtW32Catch {
...
}
#else
catch(...) {
...
}
#endif
Otherwise neither pthreads cancelation nor pthread_exit() will work
reliably when using versions of the library that use C++ exceptions
for cancelation and thread exit.
This is due to what is believed to be a C++ compliance error in VC++
whereby you may not have multiple handlers for the same exception in
the same try/catch block. GNU G++ doesn't have this restriction.
Other name changes
------------------
All snapshots prior to and including snapshot 2000-08-13
used "_pthread_" as the prefix to library internal
functions, and "_PTHREAD_" to many library internal
macros. These have now been changed to "ptw32_" and "PTW32_"
respectively so as to not conflict with the ANSI standard's
reservation of identifiers beginning with "_" and "__" for
use by compiler implementations only.
If you have written any applications and you are linking
statically with the pthreads-win32 library then you may have
included a call to _pthread_processInitialize. You will
now have to change that to ptw32_processInitialize.
Cleanup code default style
--------------------------
Previously, if not defined, the cleanup style was determined automatically
from the compiler used, and one of the following was defined accordingly:
__CLEANUP_SEH MSVC only
__CLEANUP_CXX C++, including MSVC++, GNU G++
__CLEANUP_C C, including GNU GCC, not MSVC
These defines determine the style of cleanup (see pthread.h) and,
most importantly, the way that cancelation and thread exit (via
pthread_exit) is performed (see the routine ptw32_throw()).
In short, the exceptions versions of the library throw an exception
when a thread is canceled, or exits via pthread_exit(). This exception is
caught by a handler in the thread startup routine, so that the
the correct stack unwinding occurs regardless of where the thread
is when it's canceled or exits via pthread_exit().
In this snapshot, unless the build explicitly defines (e.g. via a
compiler option) __CLEANUP_SEH, __CLEANUP_CXX, or __CLEANUP_C, then
the build NOW always defaults to __CLEANUP_C style cleanup. This style
uses setjmp/longjmp in the cancelation and pthread_exit implementations,
and therefore won't do stack unwinding even when linked to applications
that have it (e.g. C++ apps). This is for consistency with most/all
commercial Unix POSIX threads implementations.
Although it was not clearly documented before, it is still necessary to
build your application using the same __CLEANUP_* define as was
used for the version of the library that you link with, so that the
correct parts of pthread.h are included. That is, the possible
defines require the following library versions:
__CLEANUP_SEH pthreadVSE.dll
__CLEANUP_CXX pthreadVCE.dll or pthreadGCE.dll
__CLEANUP_C pthreadVC.dll or pthreadGC.dll
It is recommended that you let pthread.h use it's default __CLEANUP_C
for both library and application builds. That is, don't define any of
the above, and then link with pthreadVC.lib (MSVC or MSVC++) and
libpthreadGC.a (MinGW GCC or G++). The reason is explained below, but
another reason is that the prebuilt pthreadVCE.dll is currently broken.
Versions built with MSVC++ later than version 6 may not be broken, but I
can't verify this yet.
WHY ARE WE MAKING THE DEFAULT STYLE LESS EXCEPTION-FRIENDLY?
Because no commercial Unix POSIX threads implementation allows you to
choose to have stack unwinding. Therefore, providing it in pthread-win32
as a default is dangerous. We still provide the choice but unless
you consciously choose to do otherwise, your pthreads applications will
now run or crash in similar ways irrespective of the pthreads platform
you use. Or at least this is the hope.
Building under VC++ using C++ EH, Structured EH, or just C
----------------------------------------------------------
From the source directory run nmake without any arguments to list
help information. E.g.
$ nmake
Microsoft (R) Program Maintenance Utility Version 6.00.8168.0
Copyright (C) Microsoft Corp 1988-1998. All rights reserved.
Run one of the following command lines:
nmake clean VCE (to build the MSVC dll with C++ exception handling)
nmake clean VSE (to build the MSVC dll with structured exception handling)
nmake clean VC (to build the MSVC dll with C cleanup code)
nmake clean VCE-inlined (to build the MSVC inlined dll with C++ exception handling)
nmake clean VSE-inlined (to build the MSVC inlined dll with structured exception handling)
nmake clean VC-inlined (to build the MSVC inlined dll with C cleanup code)
nmake clean VC-static (to build the MSVC static lib with C cleanup code)
nmake clean VCE-debug (to build the debug MSVC dll with C++ exception handling)
nmake clean VSE-debug (to build the debug MSVC dll with structured exception handling)
nmake clean VC-debug (to build the debug MSVC dll with C cleanup code)
nmake clean VCE-inlined-debug (to build the debug MSVC inlined dll with C++ exception handling)
nmake clean VSE-inlined-debug (to build the debug MSVC inlined dll with structured exception handling)
nmake clean VC-inlined-debug (to build the debug MSVC inlined dll with C cleanup code)
nmake clean VC-static-debug (to build the debug MSVC static lib with C cleanup code)
The pre-built dlls are normally built using the *-inlined targets.
You can run the testsuite by changing to the "tests" directory and
running nmake. E.g.:
$ cd tests
$ nmake
Microsoft (R) Program Maintenance Utility Version 6.00.8168.0
Copyright (C) Microsoft Corp 1988-1998. All rights reserved.
Run one of the following command lines:
nmake clean VC (to test using VC dll with VC (no EH) applications)
nmake clean VCX (to test using VC dll with VC++ (EH) applications)
nmake clean VCE (to test using the VCE dll with VC++ EH applications)
nmake clean VSE (to test using VSE dll with VC (SEH) applications)
nmake clean VC-bench (to benchtest using VC dll with C bench app)
nmake clean VCX-bench (to benchtest using VC dll with C++ bench app)
nmake clean VCE-bench (to benchtest using VCE dll with C++ bench app)
nmake clean VSE-bench (to benchtest using VSE dll with SEH bench app)
nmake clean VC-static (to test using VC static lib with VC (no EH) applications)
Building under Mingw32
----------------------
The dll can be built easily with recent versions of Mingw32.
(The distributed versions are built using Mingw32 and MsysDTK
from www.mingw32.org.)
From the source directory, run make for help information. E.g.:
$ make
Run one of the following command lines:
make clean GC (to build the GNU C dll with C cleanup code)
make clean GCE (to build the GNU C dll with C++ exception handling)
make clean GC-inlined (to build the GNU C inlined dll with C cleanup code)
make clean GCE-inlined (to build the GNU C inlined dll with C++ exception handling)
make clean GC-static (to build the GNU C inlined static lib with C cleanup code)
make clean GC-debug (to build the GNU C debug dll with C cleanup code)
make clean GCE-debug (to build the GNU C debug dll with C++ exception handling)
make clean GC-inlined-debug (to build the GNU C inlined debug dll with C cleanup code)
make clean GCE-inlined-debug (to build the GNU C inlined debug dll with C++ exception handling)
make clean GC-static-debug (to build the GNU C inlined static debug lib with C cleanup code)
The pre-built dlls are normally built using the *-inlined targets.
You can run the testsuite by changing to the "tests" directory and
running make for help information. E.g.:
$ cd tests
$ make
Run one of the following command lines:
make clean GC (to test using GC dll with C (no EH) applications)
make clean GCX (to test using GC dll with C++ (EH) applications)
make clean GCE (to test using GCE dll with C++ (EH) applications)
make clean GC-bench (to benchtest using GNU C dll with C cleanup code)
make clean GCE-bench (to benchtest using GNU C dll with C++ exception handling)
make clean GC-static (to test using GC static lib with C (no EH) applications)
Building under Linux using the Mingw32 cross development tools
--------------------------------------------------------------
You can build the library without leaving Linux by using the Mingw32 cross
development toolchain. See http://www.libsdl.org/extras/win32/cross/ for
tools and info. The GNUmakefile contains some support for this, for example:
make CROSS=i386-mingw32msvc- clean GC-inlined
will build pthreadGCn.dll and libpthreadGCn.a (n=version#), provided your
cross-tools/bin directory is in your PATH (or use the cross-make.sh script
at the URL above).
Building the library as a statically linkable library
-----------------------------------------------------
General: PTW32_STATIC_LIB must be defined for both the library build and the
application build. The makefiles supplied and used by the following 'make'
command lines will define this for you.
MSVC (creates pthreadVCn.lib as a static link lib):
nmake clean VC-static
MinGW32 (creates libpthreadGCn.a as a static link lib):
make clean GC-static
Define PTW32_STATIC_LIB when building your application. Also, your
application must call a two non-portable routines to initialise the
some state on startup and cleanup before exit. One other routine needs
to be called to cleanup after any Win32 threads have called POSIX API
routines. See README.NONPORTABLE or the html reference manual pages for
details on these routines:
BOOL pthread_win32_process_attach_np (void);
BOOL pthread_win32_process_detach_np (void);
BOOL pthread_win32_thread_attach_np (void); // Currently a no-op
BOOL pthread_win32_thread_detach_np (void);
The tests makefiles have the same targets but only check that the
static library is statically linkable. They don't run the full
testsuite. To run the full testsuite, build the dlls and run the
dll test targets.
Building the library under Cygwin
---------------------------------
Cygwin is implementing it's own POSIX threads routines and these
will be the ones to use if you develop using Cygwin.
Ready to run binaries
---------------------
For convenience, the following ready-to-run files can be downloaded
from the FTP site (see under "Availability" below):
pthread.h
semaphore.h
sched.h
pthreadVC.dll - built with MSVC compiler using C setjmp/longjmp
pthreadVC.lib
pthreadVCE.dll - built with MSVC++ compiler using C++ EH
pthreadVCE.lib
pthreadVSE.dll - built with MSVC compiler using SEH
pthreadVSE.lib
pthreadGC.dll - built with Mingw32 GCC
libpthreadGC.a - derived from pthreadGC.dll
pthreadGCE.dll - built with Mingw32 G++
libpthreadGCE.a - derived from pthreadGCE.dll
As of August 2003 pthreads-win32 pthreadG* versions are built and tested
using the MinGW + MsysDTK environment current as of that date or later.
The following file MAY be needed for older MinGW environments.
gcc.dll - needed to build and run applications that use
pthreadGCE.dll.
Building applications with GNU compilers
----------------------------------------
If you're using pthreadGC.dll:
With the three header files, pthreadGC.dll and libpthreadGC.a in the
same directory as your application myapp.c, you could compile, link
and run myapp.c under Mingw32 as follows:
gcc -o myapp.exe myapp.c -I. -L. -lpthreadGC
myapp
Or put pthreadGC.dll in an appropriate directory in your PATH,
put libpthreadGC.a in your system lib directory, and
put the three header files in your system include directory,
then use:
gcc -o myapp.exe myapp.c -lpthreadGC
myapp
If you're using pthreadGCE.dll:
With the three header files, pthreadGCE.dll, gcc.dll and libpthreadGCE.a
in the same directory as your application myapp.c, you could compile,
link and run myapp.c under Mingw32 as follows:
gcc -x c++ -o myapp.exe myapp.c -I. -L. -lpthreadGCE
myapp
Or put pthreadGCE.dll and gcc.dll in an appropriate directory in
your PATH, put libpthreadGCE.a in your system lib directory, and
put the three header files in your system include directory,
then use:
gcc -x c++ -o myapp.exe myapp.c -lpthreadGCE
myapp
Availability
------------
The complete source code in either unbundled, self-extracting
Zip file, or tar/gzipped format can be found at:
ftp://sources.redhat.com/pub/pthreads-win32
The pre-built DLL, export libraries and matching pthread.h can
be found at:
ftp://sources.redhat.com/pub/pthreads-win32/dll-latest
Home page:
http://sources.redhat.com/pthreads-win32/
Mailing list
------------
There is a mailing list for discussing pthreads on Win32.
To join, send email to:
pthreads-win32-subscribe@sources.redhat.com
Unsubscribe by sending mail to:
pthreads-win32-unsubscribe@sources.redhat.com
Acknowledgements
----------------
See the ANNOUNCE file for acknowledgements.
See the 'CONTRIBUTORS' file for the list of contributors.
As much as possible, the ChangeLog file attributes
contributions and patches that have been incorporated
in the library to the individuals responsible.
Finally, thanks to all those who work on and contribute to the
POSIX and Single Unix Specification standards. The maturity of an
industry can be measured by it's open standards.
----
Ross Johnson
<rpj@callisto.canberra.edu.au>

57
3rdparty/pthreads4w/README.Borland vendored
View File

@ -1,57 +0,0 @@
In ptw32_InterlockedCompareExchange.c, I've added a section for
Borland's compiler; it's identical to that for the MS compiler except
that it uses /* ... */ comments instead of ; comments.
[RPJ: need to define HAVE_TASM32 in config.h to use the above.]
The other file is a makefile suitable for use with Borland's compiler
(run "make -fBmakefile" in the directory). It builds a single version
of the library, pthreadBC.dll and the corresponding pthreadBC.lib
import library, which is comparable to the pthreadVC version; I can't
personally see any demand for the versions that include structured or
C++ exception cancellation handling so I haven't attempted to build
those versions of the library. (I imagine a static version might be
of use to some, but we can't legally use that on my commercial
projects so I can't try that out, unfortunately.)
[RPJ: Added tests\Bmakefile as well.]
Borland C++ doesn't define the ENOSYS constant used by pthreads-win32;
rather than make more extensive patches to the pthreads-win32 source I
have a mostly-arbitrary constant for it in the makefile. However this
doesn't make it visible to the application using the library, so if
anyone actually wants to use this constant in their apps (why?)
someone might like to make a seperate NEED_BCC_something define to add
this stuff.
The makefile also #defines EDEADLK as EDEADLOCK, _timeb as timeb, and
_ftime as ftime, to deal with the minor differences between the two
RTLs' naming conventions, and sets the compiler flags as required to
get a normal compile of the library.
[RPJ: Moved errno values and _timeb etc to pthread.h, so apps will also
use them.]
(While I'm on the subject, the reason Borland users should recompile
the library, rather than using the impdef/implib technique suggested
previously on the mailing list, is that a) the errno constants are
different, so the results returned by the pthread_* functions can be
meaningless, and b) the errno variable/pseudo-variable itself is
different in the MS & BCC runtimes, so you can't access the
pthreadVC's errno from a Borland C++-compiled host application
correctly - I imagine there are other potential problems from the RTL
mismatch too.)
[RPJ: Make sure you use the same RTL in both dll and application builds.
The dll and tests Bmakefiles use cw32mti.lib. Having some trouble with
memory read exceptions running the test suite using BCC55.]
Best regards,
Will
--
Will Bryant
Systems Architect, eCOSM Limited
Cell +64 21 655 443, office +64 3 365 4176
http://www.ecosm.com/

3036
3rdparty/pthreads4w/README.CV vendored
View File

File diff suppressed because it is too large Load Diff

783
3rdparty/pthreads4w/README.NONPORTABLE vendored
View File

@ -1,783 +0,0 @@
This file documents non-portable functions and other issues.
Non-portable functions included in pthreads-win32
-------------------------------------------------
BOOL
pthread_win32_test_features_np(int mask)
This routine allows an application to check which
run-time auto-detected features are available within
the library.
The possible features are:
PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE
Return TRUE if the native version of
InterlockedCompareExchange() is being used.
This feature is not meaningful in recent
library versions as MSVC builds only support
system implemented ICE. Note that all Mingw
builds use inlined asm versions of all the
Interlocked routines.
PTW32_ALERTABLE_ASYNC_CANCEL
Return TRUE is the QueueUserAPCEx package
QUSEREX.DLL is available and the AlertDrv.sys
driver is loaded into Windows, providing
alertable (pre-emptive) asyncronous threads
cancelation. If this feature returns FALSE
then the default async cancel scheme is in
use, which cannot cancel blocked threads.
Features may be Or'ed into the mask parameter, in which case
the routine returns TRUE if any of the Or'ed features would
return TRUE. At this stage it doesn't make sense to Or features
but it may some day.
void *
pthread_timechange_handler_np(void *)
To improve tolerance against operator or time service
initiated system clock changes.
This routine can be called by an application when it
receives a WM_TIMECHANGE message from the system. At
present it broadcasts all condition variables so that
waiting threads can wake up and re-evaluate their
conditions and restart their timed waits if required.
It has the same return type and argument type as a
thread routine so that it may be called directly
through pthread_create(), i.e. as a separate thread.
Parameters
Although a parameter must be supplied, it is ignored.
The value NULL can be used.
Return values
It can return an error EAGAIN to indicate that not
all condition variables were broadcast for some reason.
Otherwise, 0 is returned.
If run as a thread, the return value is returned
through pthread_join().
The return value should be cast to an integer.
HANDLE
pthread_getw32threadhandle_np(pthread_t thread);
Returns the win32 thread handle that the POSIX
thread "thread" is running as.
Applications can use the win32 handle to set
win32 specific attributes of the thread.
DWORD
pthread_getw32threadid_np (pthread_t thread)
Returns the Windows native thread ID that the POSIX
thread "thread" is running as.
Only valid when the library is built where
! (defined(__MINGW64__) || defined(__MINGW32__)) || defined (__MSVCRT__) || defined (__DMC__)
and otherwise returns 0.
int
pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr, int kind)
int
pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr, int *kind)
These two routines are included for Linux compatibility
and are direct equivalents to the standard routines
pthread_mutexattr_settype
pthread_mutexattr_gettype
pthread_mutexattr_setkind_np accepts the following
mutex kinds:
PTHREAD_MUTEX_FAST_NP
PTHREAD_MUTEX_ERRORCHECK_NP
PTHREAD_MUTEX_RECURSIVE_NP
These are really just equivalent to (respectively):
PTHREAD_MUTEX_NORMAL
PTHREAD_MUTEX_ERRORCHECK
PTHREAD_MUTEX_RECURSIVE
int
pthread_delay_np (const struct timespec *interval);
This routine causes a thread to delay execution for a specific period of time.
This period ends at the current time plus the specified interval. The routine
will not return before the end of the period is reached, but may return an
arbitrary amount of time after the period has gone by. This can be due to
system load, thread priorities, and system timer granularity.
Specifying an interval of zero (0) seconds and zero (0) nanoseconds is
allowed and can be used to force the thread to give up the processor or to
deliver a pending cancelation request.
This routine is a cancelation point.
The timespec structure contains the following two fields:
tv_sec is an integer number of seconds.
tv_nsec is an integer number of nanoseconds.
Return Values
If an error condition occurs, this routine returns an integer value
indicating the type of error. Possible return values are as follows:
0 Successful completion.
[EINVAL] The value specified by interval is invalid.
int
pthread_num_processors_np (void)
This routine (found on HPUX systems) returns the number of processors
in the system. This implementation actually returns the number of
processors available to the process, which can be a lower number
than the system's number, depending on the process's affinity mask.
BOOL
pthread_win32_process_attach_np (void);
BOOL
pthread_win32_process_detach_np (void);
BOOL
pthread_win32_thread_attach_np (void);
BOOL
pthread_win32_thread_detach_np (void);
These functions contain the code normally run via dllMain
when the library is used as a dll but which need to be
called explicitly by an application when the library
is statically linked. As of version 2.9.0 of the library, static
builds using either MSC or GCC will call pthread_win32_process_*
automatically at application startup and exit respectively.
Otherwise, you will need to call pthread_win32_process_attach_np()
before you can call any pthread routines when statically linking.
You should call pthread_win32_process_detach_np() before
exiting your application to clean up.
pthread_win32_thread_attach_np() is currently a no-op, but
pthread_win32_thread_detach_np() is needed to clean up
the implicit pthread handle that is allocated to a Win32 thread if
it calls any pthreads routines. Call this routine when the
Win32 thread exits.
Threads created through pthread_create() do not need to call
pthread_win32_thread_detach_np().
These functions invariably return TRUE except for
pthread_win32_process_attach_np() which will return FALSE
if pthreads-win32 initialisation fails.
int
pthreadCancelableWait (HANDLE waitHandle);
int
pthreadCancelableTimedWait (HANDLE waitHandle, DWORD timeout);
These two functions provide hooks into the pthread_cancel
mechanism that will allow you to wait on a Windows handle
and make it a cancellation point. Both functions block
until either the given w32 handle is signaled, or
pthread_cancel has been called. It is implemented using
WaitForMultipleObjects on 'waitHandle' and a manually
reset w32 event used to implement pthread_cancel.
Non-portable issues
-------------------
Thread priority
POSIX defines a single contiguous range of numbers that determine a
thread's priority. Win32 defines priority classes and priority
levels relative to these classes. Classes are simply priority base
levels that the defined priority levels are relative to such that,
changing a process's priority class will change the priority of all
of it's threads, while the threads retain the same relativity to each
other.
A Win32 system defines a single contiguous monotonic range of values
that define system priority levels, just like POSIX. However, Win32
restricts individual threads to a subset of this range on a
per-process basis.
The following table shows the base priority levels for combinations
of priority class and priority value in Win32.
Process Priority Class Thread Priority Level
-----------------------------------------------------------------
1 IDLE_PRIORITY_CLASS THREAD_PRIORITY_IDLE
1 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_IDLE
1 NORMAL_PRIORITY_CLASS THREAD_PRIORITY_IDLE
1 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_IDLE
1 HIGH_PRIORITY_CLASS THREAD_PRIORITY_IDLE
2 IDLE_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
3 IDLE_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
4 IDLE_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
4 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
5 IDLE_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
5 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
5 Background NORMAL_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
6 IDLE_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
6 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
6 Background NORMAL_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
7 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
7 Background NORMAL_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
7 Foreground NORMAL_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
8 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
8 NORMAL_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
8 Foreground NORMAL_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
8 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
9 NORMAL_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
9 Foreground NORMAL_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
9 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
10 Foreground NORMAL_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
10 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
11 Foreground NORMAL_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
11 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
11 HIGH_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
12 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
12 HIGH_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
13 HIGH_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
14 HIGH_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
15 HIGH_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
15 HIGH_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
15 IDLE_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
15 BELOW_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
15 NORMAL_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
15 ABOVE_NORMAL_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
16 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_IDLE
17 REALTIME_PRIORITY_CLASS -7
18 REALTIME_PRIORITY_CLASS -6
19 REALTIME_PRIORITY_CLASS -5
20 REALTIME_PRIORITY_CLASS -4
21 REALTIME_PRIORITY_CLASS -3
22 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_LOWEST
23 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_BELOW_NORMAL
24 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_NORMAL
25 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_ABOVE_NORMAL
26 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_HIGHEST
27 REALTIME_PRIORITY_CLASS 3
28 REALTIME_PRIORITY_CLASS 4
29 REALTIME_PRIORITY_CLASS 5
30 REALTIME_PRIORITY_CLASS 6
31 REALTIME_PRIORITY_CLASS THREAD_PRIORITY_TIME_CRITICAL
Windows NT: Values -7, -6, -5, -4, -3, 3, 4, 5, and 6 are not supported.
As you can see, the real priority levels available to any individual
Win32 thread are non-contiguous.
An application using pthreads-win32 should not make assumptions about
the numbers used to represent thread priority levels, except that they
are monotonic between the values returned by sched_get_priority_min()
and sched_get_priority_max(). E.g. Windows 95, 98, NT, 2000, XP make
available a non-contiguous range of numbers between -15 and 15, while
at least one version of WinCE (3.0) defines the minimum priority
(THREAD_PRIORITY_LOWEST) as 5, and the maximum priority
(THREAD_PRIORITY_HIGHEST) as 1.
Internally, pthreads-win32 maps any priority levels between
THREAD_PRIORITY_IDLE and THREAD_PRIORITY_LOWEST to THREAD_PRIORITY_LOWEST,
or between THREAD_PRIORITY_TIME_CRITICAL and THREAD_PRIORITY_HIGHEST to
THREAD_PRIORITY_HIGHEST. Currently, this also applies to
REALTIME_PRIORITY_CLASSi even if levels -7, -6, -5, -4, -3, 3, 4, 5, and 6
are supported.
If it wishes, a Win32 application using pthreads-win32 can use the Win32
defined priority macros THREAD_PRIORITY_IDLE through
THREAD_PRIORITY_TIME_CRITICAL.
The opacity of the pthread_t datatype
-------------------------------------
and possible solutions for portable null/compare/hash, etc
----------------------------------------------------------
Because pthread_t is an opague datatype an implementation is permitted to define
pthread_t in any way it wishes. That includes defining some bits, if it is
scalar, or members, if it is an aggregate, to store information that may be
extra to the unique identifying value of the ID. As a result, pthread_t values
may not be directly comparable.
If you want your code to be portable you must adhere to the following contraints:
1) Don't assume it is a scalar data type, e.g. an integer or pointer value. There
are several other implementations where pthread_t is also a struct. See our FAQ
Question 11 for our reasons for defining pthread_t as a struct.
2) You must not compare them using relational or equality operators. You must use
the API function pthread_equal() to test for equality.
3) Never attempt to reference individual members.
The problem
Certain applications would like to be able to access only the 'pure' pthread_t
id values, primarily to use as keys into data structures to manage threads or
thread-related data, but this is not possible in a maximally portable and
standards compliant way for current POSIX threads implementations.
For implementations that define pthread_t as a scalar, programmers often employ
direct relational and equality operators on pthread_t. This code will break when
ported to an implementation that defines pthread_t as an aggregate type.
For implementations that define pthread_t as an aggregate, e.g. a struct,
programmers can use memcmp etc., but then face the prospect that the struct may
include alignment padding bytes or bits as well as extra implementation-specific
members that are not part of the unique identifying value.
[While this is not currently the case for pthreads-win32, opacity also
means that an implementation is free to change the definition, which should
generally only require that applications be recompiled and relinked, not
rewritten.]
Doesn't the compiler take care of padding?
The C89 and later standards only effectively guarrantee element-by-element
equivalence following an assignment or pass by value of a struct or union,
therefore undefined areas of any two otherwise equivalent pthread_t instances
can still compare differently, e.g. attempting to compare two such pthread_t
variables byte-by-byte, e.g. memcmp(&t1, &t2, sizeof(pthread_t) may give an
incorrect result. In practice I'm reasonably confident that compilers routinely
also copy the padding bytes, mainly because assignment of unions would be far
too complicated otherwise. But it just isn't guarranteed by the standard.
Illustration:
We have two thread IDs t1 and t2
pthread_t t1, t2;
In an application we create the threads and intend to store the thread IDs in an
ordered data structure (linked list, tree, etc) so we need to be able to compare
them in order to insert them initially and also to traverse.
Suppose pthread_t contains undefined padding bits and our compiler copies our
pthread_t [struct] element-by-element, then for the assignment:
pthread_t temp = t1;
temp and t1 will be equivalent and correct but a byte-for-byte comparison such as
memcmp(&temp, &t1, sizeof(pthread_t)) == 0 may not return true as we expect because
the undefined bits may not have the same values in the two variable instances.
Similarly if passing by value under the same conditions.
If, on the other hand, the undefined bits are at least constant through every
assignment and pass-by-value then the byte-for-byte comparison
memcmp(&temp, &t1, sizeof(pthread_t)) == 0 will always return the expected result.
How can we force the behaviour we need?
Solutions
Adding new functions to the standard API or as non-portable extentions is
the only reliable and portable way to provide the necessary operations.
Remember also that POSIX is not tied to the C language. The most common
functions that have been suggested are:
pthread_null()
pthread_compare()
pthread_hash()
A single more general purpose function could also be defined as a
basis for at least the last two of the above functions.
First we need to list the freedoms and constraints with restpect
to pthread_t so that we can be sure our solution is compatible with the
standard.
What is known or may be deduced from the standard:
1) pthread_t must be able to be passed by value, so it must be a single object.
2) from (1) it must be copyable so cannot embed thread-state information, locks
or other volatile objects required to manage the thread it associates with.
3) pthread_t may carry additional information, e.g. for debugging or to manage
itself.
4) there is an implicit requirement that the size of pthread_t is determinable
at compile-time and size-invariant, because it must be able to copy the object
(i.e. through assignment and pass-by-value). Such copies must be genuine
duplicates, not merely a copy of a pointer to a common instance such as
would be the case if pthread_t were defined as an array.
Suppose we define the following function:
/* This function shall return it's argument */
pthread_t* pthread_normalize(pthread_t* thread);
For scalar or aggregate pthread_t types this function would simply zero any bits
within the pthread_t that don't uniquely identify the thread, including padding,
such that client code can return consistent results from operations done on the
result. If the additional bits are a pointer to an associate structure then
this function would ensure that the memory used to store that associate
structure does not leak. After normalization the following compare would be
valid and repeatable:
memcmp(pthread_normalize(&t1),pthread_normalize(&t2),sizeof(pthread_t))
Note 1: such comparisons are intended merely to order and sort pthread_t values
and allow them to index various data structures. They are not intended to reveal
anything about the relationships between threads, like startup order.
Note 2: the normalized pthread_t is also a valid pthread_t that uniquely
identifies the same thread.
Advantages:
1) In most existing implementations this function would reduce to a no-op that
emits no additional instructions, i.e after in-lining or optimisation, or if
defined as a macro:
#define pthread_normalise(tptr) (tptr)
2) This single function allows an application to portably derive
application-level versions of any of the other required functions.
3) It is a generic function that could enable unanticipated uses.
Disadvantages:
1) Less efficient than dedicated compare or hash functions for implementations
that include significant extra non-id elements in pthread_t.
2) Still need to be concerned about padding if copying normalized pthread_t.
See the later section on defining pthread_t to neutralise padding issues.
Generally a pthread_t may need to be normalized every time it is used,
which could have a significant impact. However, this is a design decision
for the implementor in a competitive environment. An implementation is free
to define a pthread_t in a way that minimises or eliminates padding or
renders this function a no-op.
Hazards:
1) Pass-by-reference directly modifies 'thread' so the application must
synchronise access or ensure that the pointer refers to a copy. The alternative
of pass-by-value/return-by-value was considered but then this requires two copy
operations, disadvantaging implementations where this function is not a no-op
in terms of speed of execution. This function is intended to be used in high
frequency situations and needs to be efficient, or at least not unnecessarily
inefficient. The alternative also sits awkwardly with functions like memcmp.
2) [Non-compliant] code that uses relational and equality operators on
arithmetic or pointer style pthread_t types would need to be rewritten, but it
should be rewritten anyway.
C implementation of null/compare/hash functions using pthread_normalize():
/* In pthread.h */
pthread_t* pthread_normalize(pthread_t* thread);
/* In user code */
/* User-level bitclear function - clear bits in loc corresponding to mask */
void* bitclear (void* loc, void* mask, size_t count);
typedef unsigned int hash_t;
/* User-level hash function */
hash_t hash(void* ptr, size_t count);
/*
* User-level pthr_null function - modifies the origin thread handle.
* The concept of a null pthread_t is highly implementation dependent
* and this design may be far from the mark. For example, in an
* implementation "null" may mean setting a special value inside one
* element of pthread_t to mean "INVALID". However, if that value was zero and
* formed part of the id component then we may get away with this design.
*/
pthread_t* pthr_null(pthread_t* tp)
{
/*
* This should have the same effect as memset(tp, 0, sizeof(pthread_t))
* We're just showing that we can do it.
*/
void* p = (void*) pthread_normalize(tp);
return (pthread_t*) bitclear(p, p, sizeof(pthread_t));
}
/*
* Safe user-level pthr_compare function - modifies temporary thread handle copies
*/
int pthr_compare_safe(pthread_t thread1, pthread_t thread2)
{
return memcmp(pthread_normalize(&thread1), pthread_normalize(&thread2), sizeof(pthread_t));
}
/*
* Fast user-level pthr_compare function - modifies origin thread handles
*/
int pthr_compare_fast(pthread_t* thread1, pthread_t* thread2)
{
return memcmp(pthread_normalize(&thread1), pthread_normalize(&thread2), sizeof(pthread_t));
}
/*
* Safe user-level pthr_hash function - modifies temporary thread handle copy
*/
hash_t pthr_hash_safe(pthread_t thread)
{
return hash((void *) pthread_normalize(&thread), sizeof(pthread_t));
}
/*
* Fast user-level pthr_hash function - modifies origin thread handle
*/
hash_t pthr_hash_fast(pthread_t thread)
{
return hash((void *) pthread_normalize(&thread), sizeof(pthread_t));
}
/* User-level bitclear function - modifies the origin array */
void* bitclear(void* loc, void* mask, size_t count)
{
int i;
for (i=0; i < count; i++) {
(unsigned char) *loc++ &= ~((unsigned char) *mask++);
}
}
/* Donald Knuth hash */
hash_t hash(void* str, size_t count)
{
hash_t hash = (hash_t) count;
unsigned int i = 0;
for(i = 0; i < len; str++, i++)
{
hash = ((hash << 5) ^ (hash >> 27)) ^ (*str);
}
return hash;
}
/* Example of advantage point (3) - split a thread handle into its id and non-id values */
pthread_t id = thread, non-id = thread;
bitclear((void*) &non-id, (void*) pthread_normalize(&id), sizeof(pthread_t));
A pthread_t type change proposal to neutralise the effects of padding
Even if pthread_nornalize() is available, padding is still a problem because
the standard only garrantees element-by-element equivalence through
copy operations (assignment and pass-by-value). So padding bit values can
still change randomly after calls to pthread_normalize().
[I suspect that most compilers take the easy path and always byte-copy anyway,
partly because it becomes too complex to do (e.g. unions that contain sub-aggregates)
but also because programmers can easily design their aggregates to minimise and
often eliminate padding].
How can we eliminate the problem of padding bytes in structs? Could
defining pthread_t as a union rather than a struct provide a solution?
In fact, the Linux pthread.h defines most of it's pthread_*_t objects (but not
pthread_t itself) as unions, possibly for this and/or other reasons. We'll
borrow some element naming from there but the ideas themselves are well known
- the __align element used to force alignment of the union comes from K&R's
storage allocator example.
/* Essentially our current pthread_t renamed */
typedef struct {
struct thread_state_t * __p;
long __x; /* sequence counter */
} thread_id_t;
Ensuring that the last element in the above struct is a long ensures that the
overall struct size is a multiple of sizeof(long), so there should be no trailing
padding in this struct or the union we define below.
(Later we'll see that we can handle internal but not trailing padding.)
/* New pthread_t */
typedef union {
char __size[sizeof(thread_id_t)]; /* array as the first element */
thread_id_t __tid;
long __align; /* Ensure that the union starts on long boundary */
} pthread_t;
This guarrantees that, during an assignment or pass-by-value, the compiler copies
every byte in our thread_id_t because the compiler guarrantees that the __size
array, which we have ensured is the equal-largest element in the union, retains
equivalence.
This means that pthread_t values stored, assigned and passed by value will at least
carry the value of any undefined padding bytes along and therefore ensure that
those values remain consistent. Our comparisons will return consistent results and
our hashes of [zero initialised] pthread_t values will also return consistent
results.
We have also removed the need for a pthread_null() function; we can initialise
at declaration time or easily create our own const pthread_t to use in assignments
later:
const pthread_t null_tid = {0}; /* braces are required */
pthread_t t;
...
t = null_tid;
Note that we don't have to explicitly make use of the __size array at all. It's
there just to force the compiler behaviour we want.
Partial solutions without a pthread_normalize function
An application-level pthread_null and pthread_compare proposal
(and pthread_hash proposal by extention)
In order to deal with the problem of scalar/aggregate pthread_t type disparity in
portable code I suggest using an old-fashioned union, e.g.:
Contraints:
- there is no padding, or padding values are preserved through assignment and
pass-by-value (see above);
- there are no extra non-id values in the pthread_t.
Example 1: A null initialiser for pthread_t variables...
typedef union {
unsigned char b[sizeof(pthread_t)];
pthread_t t;
} init_t;
const init_t initial = {0};
pthread_t tid = initial.t; /* init tid to all zeroes */
Example 2: A comparison function for pthread_t values
typedef union {
unsigned char b[sizeof(pthread_t)];
pthread_t t;
} pthcmp_t;
int pthcmp(pthread_t left, pthread_t right)
{
/*
* Compare two pthread handles in a way that imposes a repeatable but arbitrary
* ordering on them.
* I.e. given the same set of pthread_t handles the ordering should be the same
* each time but the order has no particular meaning other than that. E.g.
* the ordering does not imply the thread start sequence, or any other
* relationship between threads.
*
* Return values are:
* 1 : left is greater than right
* 0 : left is equal to right
* -1 : left is less than right
*/
int i;
pthcmp_t L, R;
L.t = left;
R.t = right;
for (i = 0; i < sizeof(pthread_t); i++)
{
if (L.b[i] > R.b[i])
return 1;
else if (L.b[i] < R.b[i])
return -1;
}
return 0;
}
It has been pointed out that the C99 standard allows for the possibility that
integer types also may include padding bits, which could invalidate the above
method. This addition to C99 was specifically included after it was pointed
out that there was one, presumably not particularly well known, architecture
that included a padding bit in it's 32 bit integer type. See section 6.2.6.2
of both the standard and the rationale, specifically the paragraph starting at
line 16 on page 43 of the rationale.
An aside
Certain compilers, e.g. gcc and one of the IBM compilers, include a feature
extention: provided the union contains a member of the same type as the
object then the object may be cast to the union itself.
We could use this feature to speed up the pthrcmp() function from example 2
above by casting rather than assigning the pthread_t arguments to the union, e.g.:
int pthcmp(pthread_t left, pthread_t right)
{
/*
* Compare two pthread handles in a way that imposes a repeatable but arbitrary
* ordering on them.
* I.e. given the same set of pthread_t handles the ordering should be the same
* each time but the order has no particular meaning other than that. E.g.
* the ordering does not imply the thread start sequence, or any other
* relationship between threads.
*
* Return values are:
* 1 : left is greater than right
* 0 : left is equal to right
* -1 : left is less than right
*/
int i;
for (i = 0; i < sizeof(pthread_t); i++)
{
if (((pthcmp_t)left).b[i] > ((pthcmp_t)right).b[i])
return 1;
else if (((pthcmp_t)left).b[i] < ((pthcmp_t)right).b[i])
return -1;
}
return 0;
}
Result thus far
We can't remove undefined bits if they are there in pthread_t already, but we have
attempted to render them inert for comparison and hashing functions by making them
consistent through assignment, copy and pass-by-value.
Note: Hashing pthread_t values requires that all pthread_t variables be initialised
to the same value (usually all zeros) before being assigned a proper thread ID, i.e.
to ensure that any padding bits are zero, or at least the same value for all
pthread_t. Since all pthread_t values are generated by the library in the first
instance this need not be an application-level operation.
Conclusion
I've attempted to resolve the multiple issues of type opacity and the possible
presence of undefined bits and bytes in pthread_t values, which prevent
applications from comparing or hashing pthread handles.
Two complimentary partial solutions have been proposed, one an application-level
scheme to handle both scalar and aggregate pthread_t types equally, plus a
definition of pthread_t itself that neutralises padding bits and bytes by
coercing semantics out of the compiler to eliminate variations in the values of
padding bits.
I have not provided any solution to the problem of handling extra values embedded
in pthread_t, e.g. debugging or trap information that an implementation is entitled
to include. Therefore none of this replaces the portability and flexibility of API
functions but what functions are needed? The threads standard is unlikely to
include that can be implemented by a combination of existing features and more
generic functions (several references in the threads rationale suggest this.
Therefore I propose that the following function could replace the several functions
that have been suggested in conversations:
pthread_t * pthread_normalize(pthread_t * handle);
For most existing pthreads implementations this function, or macro, would reduce to
a no-op with zero call overhead.

62
3rdparty/pthreads4w/README.Watcom vendored
View File

@ -1,62 +0,0 @@
Watcom compiler notes
=====================
Status
------
Not yet usable. Although the library builds under Watcom it
substantially fails the test suite.
There is a working Wmakefile for wmake for the library build.
invoke as any of:
wmake -f Wmakefile clean WC
wmake -f Wmakefile clean WC-inlined
wmake -f Wmakefile clean WCE
wmake -f Wmakefile clean WCE-inlined
These build pthreadWC.dll and pthreadWCE.dll.
There is a working Wmakefile for wmake for the test suite.
invoke as any of:
wmake -f Wmakefile clean WC
wmake -f Wmakefile clean WCX
wmake -f Wmakefile clean WCE
wmake -f Wmakefile clean WC-bench
wmake -f Wmakefile clean WCX-bench
wmake -f Wmakefile clean WCE-bench
Current known problems
----------------------
Library build:
The Watcom compiler uses a different default call convention to MS C or GNU C and so
applications are not compatible with pthreadVC.dll etc using pre 2003-10-14 versions
of pthread.h, sched.h, or semaphore.h. The cdecl attribute can be used on exposed
function prototypes to force compatibility with MS C built DLLs.
However, there appear to be other incompatibilities. Errno.h, for example, defines
different values for the standard C and POSIX errors to those defined by the MS C
errno.h. It may be that references to Watcom's threads compatible 'errno' do set
and return translated numbers consistently, but I have not verified this.
Watcom defines errno as a dereferenced pointer returned by the function
_get_errno_ptr(). This is similar to both the MS and GNU C environments for
multithreaded use. However, the Watcom version appears to have a number of problems:
- different threads return the same pointer value. Compare with the MS and GNU C
versions which correctly return different values (since each thread must maintain
a thread specific errno value).
- an errno value set within the DLL appears as zero in the application even though
both share the same thread.
Therefore applications built using the Watcom compiler may need to use
a Watcom built version of the library (pthreadWC.dll). If this is the case, then
the cdecl function attribute should not be required.
Application builds:
The test suite fails with the Watcom compiler.
Test semaphore1.c fails for pthreadWC.dll because errno returns 0 instead of EAGAIN.

6
3rdparty/pthreads4w/README.WinCE vendored
View File

@ -1,6 +0,0 @@
WinCE port
----------
(See the file WinCE-PORT for a detailed explanation.)
Make sure you define "WINCE" amongst your compiler flags (eg. -DWINCE).
The config.h file will define all the necessary defines for you.

7
3rdparty/pthreads4w/TODO vendored
View File

@ -1,7 +0,0 @@
Things that aren't done yet
---------------------------
1. Implement PTHREAD_PROCESS_SHARED for semaphores, mutexes,
condition variables, read/write locks, barriers.

222
3rdparty/pthreads4w/WinCE-PORT vendored
View File

@ -1,222 +0,0 @@
NOTE: The comments in this file relate to the original WinCE port
done by Tristan Savatier. The semaphore routines have been
completely rewritten since (2005-04-25), having been progressively
broken more and more by changes to the library. All of the semaphore
routines implemented for W9x/WNT/2000 and up should now also work for
WinCE. Also, pthread_mutex_timedlock should now work.
Additional WinCE updates have been applied since this as well. Check the
ChangeLog file and search for WINCE for example. (2007-01-07)
[RPJ]
----
Some interesting news:
I have been able to port pthread-win32 to Windows-CE,
which uses a subset of the WIN32 API.
Since we intend to keep using pthread-win32 for our
Commercial WinCE developments, I would be very interested
if WinCE support could be added to the main source tree
of pthread-win32. Also, I would like to be credited
for this port :-)
Now, here is the story...
The port was performed and tested on a Casio "Cassiopeia"
PalmSize PC, which runs a MIP processor. The OS in the
Casio is WinCE version 2.11, but I used VC++ 6.0 with
the WinCE SDK for version 2.01.
I used pthread-win32 to port a heavily multithreaded
commercial application (real-time MPEG video player)
from Linux to WinCE. I consider the changes that
I have done to be quite well tested.
Overall the modifications that we had to do are minor.
The WinCE port were based on pthread-win32-snap-1999-05-30,
but I am certain that they can be integrated very easiely
to more recent versions of the source.
I have attached the modified source code:
pthread-win32-snap-1999-05-30-WinCE.
All the changes do not affect the code compiled on non-WinCE
environment, provided that the macros used for WinCE compilation
are not used, of course!
Overall description of the WinCE port:
-------------------------------------
Most of the changes had to be made in areas where
pthread-win32 was relying on some standard-C librairies
(e.g. _ftime, calloc, errno), which are not available
on WinCE. We have changed the code to use native Win32
API instead (or in some cases we made wrappers).
The Win32 Semaphores are not available,
so we had to re-implement Semaphores using mutexes
and events.
Limitations / known problems of the WinCE port:
----------------------------------------------
Not all the semaphore routines have been ported
(semaphores are defined by Posix but are not part
pf pthread). I have just done enough to make
pthread routines (that rely internally on semaphores)
work, like signal conditions.
I noticed that the Win32 threads work slightly
differently on WinCE. This may have some impact
on some tricky parts of pthread-win32, but I have
not really investigated. For example, on WinCE,
the process is killed if the main thread falls off
the bottom (or calls pthread_exit), regardless
of the existence of any other detached thread.
Microsoft manual indicates that this behavior is
deffirent from that of Windows Threads for other
Win32 platforms.
Detailed descriptions of the changes and rationals:
------------------------------------
- use a new macro NEED_ERRNO.
If defined, the code in errno.c that defines a reentrant errno
is compiled, regardless of _MT and _REENTRANT.
Rational: On WinCE, there is no support for <stdio.h>, <errno.h> or
any other standard C library, i.e. even if _MT or _REENTRANT
is defined, errno is not provided by any library. NEED_ERRNO
must be set to compile for WinCE.
------------------------------------
- In implement.h, change #include <semaphore.h> to #include "semaphore.h".
Rational: semaphore.h is provided in pthread-win32 and should not
be searched in the systems standard include. would not compile.
This change does not seem to create problems on "classic" win32
(e.g. win95).
------------------------------------
- use a new macro NEED_CALLOC.
If defined, some code in misc.c will provide a replacement
for calloc, which is not available on Win32.
------------------------------------
- use a new macro NEED_CREATETHREAD.
If defined, implement.h defines the macro _beginthreadex
and _endthreadex.
Rational: On WinCE, the wrappers _beginthreadex and _endthreadex
do not exist. The native Win32 routines must be used.
------------------------------------
- in misc.c:
#ifdef NEED_DUPLICATEHANDLE
/* DuplicateHandle does not exist on WinCE */
self->threadH = GetCurrentThread();
#else
if( !DuplicateHandle(
GetCurrentProcess(),
GetCurrentThread(),
GetCurrentProcess(),
&self->threadH,
0,
FALSE,
DUPLICATE_SAME_ACCESS ) )
{
free( self );
return (NULL);
}
#endif
Rational: On WinCE, DuplicateHandle does not exist. I could not understand
why DuplicateHandle must be used. It seems to me that getting the current
thread handle with GetCurrentThread() is sufficient, and it seems to work
perfectly fine, so maybe DuplicateHandle was just plain useless to begin with ?
------------------------------------
- In private.c, added some code at the beginning of ptw32_processInitialize
to detect the case of multiple calls to ptw32_processInitialize.
Rational: In order to debug pthread-win32, it is easier to compile
it as a regular library (it is not possible to debug DLL's on winCE).
In that case, the application must call ptw32_rocessInitialize()
explicitely, to initialize pthread-win32. It is safer in this circumstance
to handle the case where ptw32_processInitialize() is called on
an already initialized library:
int
ptw32_processInitialize (void)
{
if (ptw32_processInitialized) {
/*
* ignore if already initialized. this is useful for
* programs that uses a non-dll pthread
* library. such programs must call ptw32_processInitialize() explicitely,
* since this initialization routine is automatically called only when
* the dll is loaded.
*/
return TRUE;
}
ptw32_processInitialized = TRUE;
[...]
}
------------------------------------
- in private.c, if macro NEED_FTIME is defined, add routines to
convert timespec_to_filetime and filetime_to_timespec, and modified
code that was using _ftime() to use Win32 API instead.
Rational: _ftime is not available on WinCE. It is necessary to use
the native Win32 time API instead.
Note: the routine timespec_to_filetime is provided as a convenience and a mean
to test that filetime_to_timespec works, but it is not used by the library.
------------------------------------
- in semaphore.c, if macro NEED_SEM is defined, add code for the routines
_increase_semaphore and _decrease_semaphore, and modify significantly
the implementation of the semaphores so that it does not use CreateSemaphore.
Rational: CreateSemaphore is not available on WinCE. I had to re-implement
semaphores using mutexes and Events.
Note: Only the semaphore routines that are used by pthread are implemented
(i.e. signal conditions rely on a subset of the semaphores routines, and
this subset works). Some other semaphore routines (e.g. sem_trywait) are
not yet supported on my WinCE port (and since I don't need them, I am not
planning to do anything about them).
------------------------------------
- in tsd.c, changed the code that defines TLS_OUT_OF_INDEXES
/* TLS_OUT_OF_INDEXES not defined on WinCE */
#ifndef TLS_OUT_OF_INDEXES
#define TLS_OUT_OF_INDEXES 0xffffffff
#endif
Rational: TLS_OUT_OF_INDEXES is not defined in any standard include file
on WinCE.
------------------------------------
- added file need_errno.h
Rational: On WinCE, there is no errno.h file. need_errno.h is just a
copy of windows version of errno.h, with minor modifications due to the fact
that some of the error codes are defined by the WinCE socket library.
In pthread.h, if NEED_ERRNO is defined, the file need_errno.h is
included (instead of <errno.h>).
-- eof

53
3rdparty/pthreads4w/attr.c vendored
View File

@ -1,53 +0,0 @@
/*
* attr.c
*
* Description:
* This translation unit agregates operations on thread attribute objects.
* It is used for inline optimisation.
*
* The included modules are used separately when static executable sizes
* must be minimised.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
#include "pthread_attr_init.c"
#include "pthread_attr_destroy.c"
#include "pthread_attr_getdetachstate.c"
#include "pthread_attr_setdetachstate.c"
#include "pthread_attr_getstackaddr.c"
#include "pthread_attr_setstackaddr.c"
#include "pthread_attr_getstacksize.c"
#include "pthread_attr_setstacksize.c"
#include "pthread_attr_getscope.c"
#include "pthread_attr_setscope.c"

69
3rdparty/pthreads4w/autostatic.c vendored
View File

@ -1,69 +0,0 @@
/*
* autostatic.c
*
* Description:
* This translation unit implements static auto-init and auto-exit logic.
*
* --------------------------------------------------------------------------
*
* 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(PTW32_STATIC_LIB)
#if defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER)
#include "pthread.h"
#include "implement.h"
static void on_process_init(void)
{
pthread_win32_process_attach_np ();
}
static void on_process_exit(void)
{
pthread_win32_thread_detach_np ();
pthread_win32_process_detach_np ();
}
#if defined(__MINGW64__) || defined(__MINGW32__)
# define attribute_section(a) __attribute__((section(a)))
#elif defined(_MSC_VER)
# define attribute_section(a) __pragma(section(a,long,read)); __declspec(allocate(a))
#endif
attribute_section(".ctors") void *gcc_ctor = on_process_init;
attribute_section(".dtors") void *gcc_dtor = on_process_exit;
attribute_section(".CRT$XCU") void *msc_ctor = on_process_init;
attribute_section(".CRT$XPU") void *msc_dtor = on_process_exit;
#endif /* defined(__MINGW64__) || defined(__MINGW32__) || defined(_MSC_VER) */
#endif /* PTW32_STATIC_LIB */

47
3rdparty/pthreads4w/barrier.c vendored
View File

@ -1,47 +0,0 @@
/*
* barrier.c
*
* Description:
* This translation unit implements barrier primitives.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
#include "pthread_barrier_init.c"
#include "pthread_barrier_destroy.c"
#include "pthread_barrier_wait.c"
#include "pthread_barrierattr_init.c"
#include "pthread_barrierattr_destroy.c"
#include "pthread_barrierattr_getpshared.c"
#include "pthread_barrierattr_setpshared.c"

64
3rdparty/pthreads4w/build/pthreads4w.vcxproj vendored
View File

@ -1,64 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<Import Project="$(SolutionDir)common\vsprops\BaseProjectConfig.props" />
<Import Project="$(SolutionDir)common\vsprops\WinSDK.props" />
<PropertyGroup Label="Globals">
<ProjectGuid>{0FAE817D-9A32-4830-857E-81DA57246E16}</ProjectGuid>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<PlatformToolset>$(DefaultPlatformToolset)</PlatformToolset>
<CharacterSet>MultiByte</CharacterSet>
<WholeProgramOptimization Condition="$(Configuration.Contains(Release))">true</WholeProgramOptimization>
<UseDebugLibraries Condition="$(Configuration.Contains(Debug))">true</UseDebugLibraries>
<UseDebugLibraries Condition="!$(Configuration.Contains(Debug))">false</UseDebugLibraries>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings" />
<ImportGroup Label="PropertySheets">
<Import Project="..\..\DefaultProjectRootDir.props" />
<Import Project="..\..\3rdparty.props" />
<Import Project="..\..\..\common\vsprops\pthreads.props" />
<Import Condition="$(Configuration.Contains(Debug))" Project="..\..\..\common\vsprops\CodeGen_Debug.props" />
<Import Condition="$(Configuration.Contains(Devel))" Project="..\..\..\common\vsprops\CodeGen_Devel.props" />
<Import Condition="$(Configuration.Contains(Release))" Project="..\..\..\common\vsprops\CodeGen_Release.props" />
<Import Condition="!$(Configuration.Contains(Release))" Project="..\..\..\common\vsprops\IncrementalLinking.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup>
<CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
</PropertyGroup>
<ItemDefinitionGroup>
<ClCompile>
<PreprocessorDefinitions>HAVE_PTW32_CONFIG_H;PTW32_BUILD_INLINED;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ClCompile>
<ResourceCompile>
<AdditionalIncludeDirectories>..\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<PreprocessorDefinitions>PTW32_RC_MSC;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Platform)'=='Win32'">PTW32_ARCHx86;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<PreprocessorDefinitions Condition="'$(Platform)'=='x64'">PTW32_ARCHx64;%(PreprocessorDefinitions)</PreprocessorDefinitions>
</ResourceCompile>
<Lib>
<TargetMachine Condition="'$(Platform)'=='Win32'">MachineX86</TargetMachine>
<TargetMachine Condition="'$(Platform)'=='x64'">MachineX64</TargetMachine>
</Lib>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="..\pthread.c" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\config.h" />
<ClInclude Include="..\context.h" />
<ClInclude Include="..\implement.h" />
<ClInclude Include="..\include\pthread.h" />
<ClInclude Include="..\include\sched.h" />
<ClInclude Include="..\include\semaphore.h" />
<ClInclude Include="..\need_errno.h" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="..\version.rc" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets" />
</Project>

50
3rdparty/pthreads4w/build/pthreads4w.vcxproj.filters vendored
View File

@ -1,50 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="..\version.rc">
<Filter>Resource Files</Filter>
</ResourceCompile>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\pthread.c">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\config.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\context.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\implement.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\need_errno.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\include\pthread.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\include\sched.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\include\semaphore.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>

9
3rdparty/pthreads4w/builddmc.bat vendored
View File

@ -1,9 +0,0 @@
; Build the pthreads library with the Digital Mars Compiler
;
set DMCDIR=c:\dm
; RELEASE
%DMCDIR%\bin\dmc -D_WIN32_WINNT -D_MT -DHAVE_PTW32_CONFIG_H -I.;c:\dm\include -o+all -WD pthread.c user32.lib+kernel32.lib+wsock32.lib -L/impl -L/NODEBUG -L/SU:WINDOWS
; DEBUG
%DMCDIR%\bin\dmc -g -D_WIN32_WINNT -D_MT -DHAVE_PTW32_CONFIG_H -I.;c:\dm\include -o+all -WD pthread.c user32.lib+kernel32.lib+wsock32.lib -L/impl -L/SU:WINDOWS

44
3rdparty/pthreads4w/cancel.c vendored
View File

@ -1,44 +0,0 @@
/*
* cancel.c
*
* Description:
* POSIX thread functions related to thread cancellation.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
#include "pthread_setcancelstate.c"
#include "pthread_setcanceltype.c"
#include "pthread_testcancel.c"
#include "pthread_cancel.c"

148
3rdparty/pthreads4w/cleanup.c vendored
View File

@ -1,148 +0,0 @@
/*
* cleanup.c
*
* Description:
* This translation unit implements routines associated
* with cleaning up threads.
*
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
/*
* The functions ptw32_pop_cleanup and ptw32_push_cleanup
* are implemented here for applications written in C with no
* SEH or C++ destructor support.
*/
ptw32_cleanup_t *
ptw32_pop_cleanup (int execute)
/*
* ------------------------------------------------------
* DOCPUBLIC
* This function pops the most recently pushed cleanup
* handler. If execute is nonzero, then the cleanup handler
* is executed if non-null.
*
* PARAMETERS
* execute
* if nonzero, execute the cleanup handler
*
*
* DESCRIPTION
* This function pops the most recently pushed cleanup
* handler. If execute is nonzero, then the cleanup handler
* is executed if non-null.
* NOTE: specify 'execute' as nonzero to avoid duplication
* of common cleanup code.
*
* RESULTS
* N/A
*
* ------------------------------------------------------
*/
{
ptw32_cleanup_t *cleanup;
cleanup = (ptw32_cleanup_t *) pthread_getspecific (ptw32_cleanupKey);
if (cleanup != NULL)
{
if (execute && (cleanup->routine != NULL))
{
(*cleanup->routine) (cleanup->arg);
}
pthread_setspecific (ptw32_cleanupKey, (void *) cleanup->prev);
}
return (cleanup);
} /* ptw32_pop_cleanup */
void
ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
ptw32_cleanup_callback_t routine, void *arg)
/*
* ------------------------------------------------------
* DOCPUBLIC
* This function pushes a new cleanup handler onto the thread's stack
* of cleanup handlers. Each cleanup handler pushed onto the stack is
* popped and invoked with the argument 'arg' when
* a) the thread exits by calling 'pthread_exit',
* b) when the thread acts on a cancellation request,
* c) or when the thread calls pthread_cleanup_pop with a nonzero
* 'execute' argument
*
* PARAMETERS
* cleanup
* a pointer to an instance of pthread_cleanup_t,
*
* routine
* pointer to a cleanup handler,
*
* arg
* parameter to be passed to the cleanup handler
*
*
* DESCRIPTION
* This function pushes a new cleanup handler onto the thread's stack
* of cleanup handlers. Each cleanup handler pushed onto the stack is
* popped and invoked with the argument 'arg' when
* a) the thread exits by calling 'pthread_exit',
* b) when the thread acts on a cancellation request,
* c) or when the thrad calls pthread_cleanup_pop with a nonzero
* 'execute' argument
* NOTE: pthread_push_cleanup, ptw32_pop_cleanup must be paired
* in the same lexical scope.
*
* RESULTS
* pthread_cleanup_t *
* pointer to the previous cleanup
*
* ------------------------------------------------------
*/
{
cleanup->routine = routine;
cleanup->arg = arg;
cleanup->prev = (ptw32_cleanup_t *) pthread_getspecific (ptw32_cleanupKey);
pthread_setspecific (ptw32_cleanupKey, (void *) cleanup);
} /* ptw32_push_cleanup */

50
3rdparty/pthreads4w/condvar.c vendored
View File

@ -1,50 +0,0 @@
/*
* condvar.c
*
* Description:
* This translation unit implements condition variables and their primitives.
*
*
* --------------------------------------------------------------------------
*
* 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
*
*/
#include "pthread.h"
#include "implement.h"
#include "ptw32_cond_check_need_init.c"
#include "pthread_condattr_init.c"
#include "pthread_condattr_destroy.c"
#include "pthread_condattr_getpshared.c"
#include "pthread_condattr_setpshared.c"
#include "pthread_cond_init.c"
#include "pthread_cond_destroy.c"
#include "pthread_cond_wait.c"
#include "pthread_cond_signal.c"

157
3rdparty/pthreads4w/config.h vendored
View File

@ -1,157 +0,0 @@
/* config.h */
#ifndef PTW32_CONFIG_H
#define PTW32_CONFIG_H
/*********************************************************************
* Defaults: see target specific redefinitions below.
*********************************************************************/
/* We're building the pthreads-win32 library */
#define PTW32_BUILD
/* Do we know about the C type sigset_t? */
#undef HAVE_SIGSET_T
/* Define if you have the <signal.h> header file. */
#undef HAVE_SIGNAL_H
/* Define if you have the Borland TASM32 or compatible assembler. */
#undef HAVE_TASM32
/* Define if you don't have Win32 DuplicateHandle. (eg. WinCE) */
#undef NEED_DUPLICATEHANDLE
/* Define if you don't have Win32 _beginthreadex. (eg. WinCE) */
#undef NEED_CREATETHREAD
/* Define if you don't have Win32 errno. (eg. WinCE) */
#undef NEED_ERRNO
/* Define if you don't have Win32 calloc. (eg. WinCE) */
#undef NEED_CALLOC
/* Define if you don't have Win32 ftime. (eg. WinCE) */
#undef NEED_FTIME
/* Define if you don't have Win32 semaphores. (eg. WinCE 2.1 or earlier) */
#undef NEED_SEM
/* Define if you need to convert string parameters to unicode. (eg. WinCE) */
#undef NEED_UNICODE_CONSTS
/* Define if your C (not C++) compiler supports "inline" functions. */
#undef HAVE_C_INLINE
/* Do we know about type mode_t? */
#undef HAVE_MODE_T
/*
* Define if GCC has atomic builtins, i.e. __sync_* intrinsics
* __sync_lock_* is implemented in mingw32 gcc 4.5.2 at least
* so this define does not turn those on or off. If you get an
* error from __sync_lock* then consider upgrading your gcc.
*/
#undef HAVE_GCC_ATOMIC_BUILTINS
/* Define if you have the timespec struct */
#undef HAVE_STRUCT_TIMESPEC
/* Define if you don't have the GetProcessAffinityMask() */
#undef NEED_PROCESS_AFFINITY_MASK
/* Define if your version of Windows TLSGetValue() clears WSALastError
* and calling SetLastError() isn't enough restore it. You'll also need to
* link against wsock32.lib (or libwsock32.a for MinGW).
*/
#undef RETAIN_WSALASTERROR
/*
# ----------------------------------------------------------------------
# The library can be built with some alternative behaviour to better
# facilitate development of applications on Win32 that will be ported
# to other POSIX systems.
#
# Nothing described here will make the library non-compliant and strictly
# compliant applications will not be affected in any way, but
# applications that make assumptions that POSIX does not guarantee are
# not strictly compliant and may fail or misbehave with some settings.
#
# PTW32_THREAD_ID_REUSE_INCREMENT
# Purpose:
# POSIX says that applications should assume that thread IDs can be
# recycled. However, Solaris (and some other systems) use a [very large]
# sequence number as the thread ID, which provides virtual uniqueness.
# This provides a very high but finite level of safety for applications
# that are not meticulous in tracking thread lifecycles e.g. applications
# that call functions which target detached threads without some form of
# thread exit synchronisation.
#
# Usage:
# Set to any value in the range: 0 <= value < 2^wordsize.
# Set to 0 to emulate reusable thread ID behaviour like Linux or *BSD.
# Set to 1 for unique thread IDs like Solaris (this is the default).
# Set to some factor of 2^wordsize to emulate smaller word size types
# (i.e. will wrap sooner). This might be useful to emulate some embedded
# systems.
#
# define PTW32_THREAD_ID_REUSE_INCREMENT 0
#
# ----------------------------------------------------------------------
*/
#undef PTW32_THREAD_ID_REUSE_INCREMENT
/*********************************************************************
* Target specific groups
*
* If you find that these are incorrect or incomplete please report it
* to the pthreads-win32 maintainer. Thanks.
*********************************************************************/
#if defined(WINCE)
#define NEED_DUPLICATEHANDLE
#define NEED_CREATETHREAD
#define NEED_ERRNO
#define NEED_CALLOC
#define NEED_FTIME
/* #define NEED_SEM */
#define NEED_UNICODE_CONSTS
#define NEED_PROCESS_AFFINITY_MASK
/* This may not be needed */
#define RETAIN_WSALASTERROR
#endif
#if defined(_UWIN)
#define HAVE_MODE_T
#define HAVE_STRUCT_TIMESPEC
#endif
#if defined(__GNUC__)
#define HAVE_C_INLINE
#endif
#if defined(__MINGW64__)
#define HAVE_MODE_T
#define HAVE_STRUCT_TIMESPEC
#elif defined(__MINGW32__)
#define HAVE_MODE_T
#endif
#if _MSC_VER >= 1900
#define HAVE_STRUCT_TIMESPEC
#endif
#if defined(__BORLANDC__)
#endif
#if defined(__WATCOMC__)
#endif
#if defined(__DMC__)
#define HAVE_SIGNAL_H
#define HAVE_C_INLINE
#endif
#endif

74
3rdparty/pthreads4w/context.h vendored
View File

@ -1,74 +0,0 @@
/*
* context.h
*
* Description:
* POSIX thread macros related to thread cancellation.
*
* --------------------------------------------------------------------------
*
* 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
*/
#ifndef PTW32_CONTEXT_H
#define PTW32_CONTEXT_H
#undef PTW32_PROGCTR
#if defined(_M_IX86) || (defined(_X86_) && !defined(__amd64__))
#define PTW32_PROGCTR(Context) ((Context).Eip)
#endif
#if defined (_M_IA64) || defined(_IA64)
#define PTW32_PROGCTR(Context) ((Context).StIIP)
#endif
#if defined(_MIPS_) || defined(MIPS)
#define PTW32_PROGCTR(Context) ((Context).Fir)
#endif
#if defined(_ALPHA_)
#define PTW32_PROGCTR(Context) ((Context).Fir)
#endif
#if defined(_PPC_)
#define PTW32_PROGCTR(Context) ((Context).Iar)
#endif
#if defined(_AMD64_) || defined(__amd64__)
#define PTW32_PROGCTR(Context) ((Context).Rip)
#endif
#if defined(_ARM_) || defined(ARM)
#define PTW32_PROGCTR(Context) ((Context).Pc)
#endif
#if !defined(PTW32_PROGCTR)
#error Module contains CPU-specific code; modify and recompile.
#endif
#endif

308
3rdparty/pthreads4w/create.c vendored
View File

@ -1,308 +0,0 @@
/*
* create.c
*
* Description:
* This translation unit implements routines associated with spawning a new
* thread.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
#if ! defined(_UWIN) && ! defined(WINCE)
#include <process.h>
#endif
int
pthread_create (pthread_t * tid,
const pthread_attr_t * attr,
void *(PTW32_CDECL *start) (void *), void *arg)
/*
* ------------------------------------------------------
* DOCPUBLIC
* This function creates a thread running the start function,
* passing it the parameter value, 'arg'. The 'attr'
* argument specifies optional creation attributes.
* The identity of the new thread is returned
* via 'tid', which should not be NULL.
*
* PARAMETERS
* tid
* pointer to an instance of pthread_t
*
* attr
* optional pointer to an instance of pthread_attr_t
*
* start
* pointer to the starting routine for the new thread
*
* arg
* optional parameter passed to 'start'
*
*
* DESCRIPTION
* This function creates a thread running the start function,
* passing it the parameter value, 'arg'. The 'attr'
* argument specifies optional creation attributes.
* The identity of the new thread is returned
* via 'tid', which should not be the NULL pointer.
*
* RESULTS
* 0 successfully created thread,
* EINVAL attr invalid,
* EAGAIN insufficient resources.
*
* ------------------------------------------------------
*/
{
pthread_t thread;
ptw32_thread_t * tp;
register pthread_attr_t a;
HANDLE threadH = 0;
int result = EAGAIN;
int run = PTW32_TRUE;
ThreadParms *parms = NULL;
unsigned int stackSize;
int priority;
pthread_t self;
/*
* Before doing anything, check that tid can be stored through
* without invoking a memory protection error (segfault).
* Make sure that the assignment below can't be optimised out by the compiler.
* This is assured by conditionally assigning *tid again at the end.
*/
tid->x = 0;
if (attr != NULL)
{
a = *attr;
}
else
{
a = NULL;
}
if ((thread = ptw32_new ()).p == NULL)
{
goto FAIL0;
}
tp = (ptw32_thread_t *) thread.p;
priority = tp->sched_priority;
if ((parms = (ThreadParms *) malloc (sizeof (*parms))) == NULL)
{
goto FAIL0;
}
parms->tid = thread;
parms->start = start;
parms->arg = arg;
#if defined(HAVE_SIGSET_T)
/*
* Threads inherit their initial sigmask from their creator thread.
*/
self = pthread_self();
tp->sigmask = ((ptw32_thread_t *)self.p)->sigmask;
#endif /* HAVE_SIGSET_T */
if (a != NULL)
{
stackSize = (unsigned int)a->stacksize;
tp->detachState = a->detachstate;
priority = a->param.sched_priority;
#if (THREAD_PRIORITY_LOWEST > THREAD_PRIORITY_NORMAL)
/* WinCE */
#else
/* Everything else */
/*
* Thread priority must be set to a valid system level
* without altering the value set by pthread_attr_setschedparam().
*/
/*
* PTHREAD_EXPLICIT_SCHED is the default because Win32 threads
* don't inherit their creator's priority. They are started with
* THREAD_PRIORITY_NORMAL (win32 value). The result of not supplying
* an 'attr' arg to pthread_create() is equivalent to defaulting to
* PTHREAD_EXPLICIT_SCHED and priority THREAD_PRIORITY_NORMAL.
*/
if (PTHREAD_INHERIT_SCHED == a->inheritsched)
{
/*
* If the thread that called pthread_create() is a Win32 thread
* then the inherited priority could be the result of a temporary
* system adjustment. This is not the case for POSIX threads.
*/
#if ! defined(HAVE_SIGSET_T)
self = pthread_self ();
#endif
priority = ((ptw32_thread_t *) self.p)->sched_priority;
}
#endif
}
else
{
/*
* Default stackSize
*/
stackSize = PTHREAD_STACK_MIN;
}
tp->state = run ? PThreadStateInitial : PThreadStateSuspended;
tp->keys = NULL;
/*
* Threads must be started in suspended mode and resumed if necessary
* after _beginthreadex returns us the handle. Otherwise we set up a
* race condition between the creating and the created threads.
* Note that we also retain a local copy of the handle for use
* by us in case thread.p->threadH gets NULLed later but before we've
* finished with it here.
*/
#if ! (defined (__MINGW64__) || defined(__MINGW32__)) || defined (__MSVCRT__) || defined (__DMC__)
tp->threadH =
threadH =
(HANDLE) _beginthreadex ((void *) NULL, /* No security info */
stackSize, /* default stack size */
ptw32_threadStart,
parms,
(unsigned)
CREATE_SUSPENDED,
(unsigned *) &(tp->thread));
if (threadH != 0)
{
if (a != NULL)
{
(void) ptw32_setthreadpriority (thread, SCHED_OTHER, priority);
}
if (run)
{
ResumeThread (threadH);
}
}
#else
{
ptw32_mcs_local_node_t stateLock;
/*
* This lock will force pthread_threadStart() to wait until we have
* the thread handle and have set the priority.
*/
ptw32_mcs_lock_acquire(&tp->stateLock, &stateLock);
tp->threadH =
threadH =
(HANDLE) _beginthread (ptw32_threadStart, stackSize, /* default stack size */
parms);
/*
* Make the return code match _beginthreadex's.
*/
if (threadH == (HANDLE) - 1L)
{
tp->threadH = threadH = 0;
}
else
{
if (!run)
{
/*
* beginthread does not allow for create flags, so we do it now.
* Note that beginthread itself creates the thread in SUSPENDED
* mode, and then calls ResumeThread to start it.
*/
SuspendThread (threadH);
}
if (a != NULL)
{
(void) ptw32_setthreadpriority (thread, SCHED_OTHER, priority);
}
}
ptw32_mcs_lock_release (&stateLock);
}
#endif
result = (threadH != 0) ? 0 : EAGAIN;
/*
* Fall Through Intentionally
*/
/*
* ------------
* Failure Code
* ------------
*/
FAIL0:
if (result != 0)
{
ptw32_threadDestroy (thread);
tp = NULL;
if (parms != NULL)
{
free (parms);
}
}
else
{
*tid = thread;
}
#if defined(_UWIN)
if (result == 0)
pthread_count++;
#endif
return (result);
} /* pthread_create */

92
3rdparty/pthreads4w/dll.c vendored
View File

@ -1,92 +0,0 @@
/*
* dll.c
*
* Description:
* This translation unit implements DLL initialisation.
*
* --------------------------------------------------------------------------
*
* 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(PTW32_STATIC_LIB)
#include "pthread.h"
#include "implement.h"
#if defined(_MSC_VER)
/*
* lpvReserved yields an unreferenced formal parameter;
* ignore it
*/
#pragma warning( disable : 4100 )
#endif
#if defined(__cplusplus)
/*
* Dear c++: Please don't mangle this name. -thanks
*/
extern "C"
#endif /* __cplusplus */
BOOL WINAPI
DllMain (HINSTANCE hinstDll, DWORD fdwReason, LPVOID lpvReserved)
{
BOOL result = PTW32_TRUE;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
result = pthread_win32_process_attach_np ();
break;
case DLL_THREAD_ATTACH:
/*
* A thread is being created
*/
result = pthread_win32_thread_attach_np ();
break;
case DLL_THREAD_DETACH:
/*
* A thread is exiting cleanly
*/
result = pthread_win32_thread_detach_np ();
break;
case DLL_PROCESS_DETACH:
(void) pthread_win32_thread_detach_np ();
result = pthread_win32_process_detach_np ();
break;
}
return (result);
} /* DllMain */
#endif /* PTW32_STATIC_LIB */

94
3rdparty/pthreads4w/errno.c vendored
View File

@ -1,94 +0,0 @@
/*
* errno.c
*
* Description:
* This translation unit implements routines associated with spawning a new
* thread.
*
* --------------------------------------------------------------------------
*
* 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(NEED_ERRNO)
#include "pthread.h"
#include "implement.h"
static int reallyBad = ENOMEM;
/*
* Re-entrant errno.
*
* Each thread has it's own errno variable in pthread_t.
*
* The benefit of using the pthread_t structure
* instead of another TSD key is TSD keys are limited
* on Win32 to 64 per process. Secondly, to implement
* it properly without using pthread_t you'd need
* to dynamically allocate an int on starting the thread
* and store it manually into TLS and then ensure that you free
* it on thread termination. We get all that for free
* by simply storing the errno on the pthread_t structure.
*
* MSVC and Mingw32 already have their own thread-safe errno.
*
* #if defined( _REENTRANT ) || defined( _MT )
* #define errno *_errno()
*
* int *_errno( void );
* #else
* extern int errno;
* #endif
*
*/
int *
_errno (void)
{
pthread_t self;
int *result;
if ((self = pthread_self ()).p == NULL)
{
/*
* Yikes! unable to allocate a thread!
* Throw an exception? return an error?
*/
result = &reallyBad;
}
else
{
result = (int *)(&self.p->exitStatus);
}
return (result);
} /* _errno */
#endif /* (NEED_ERRNO) */

44
3rdparty/pthreads4w/exit.c vendored
View File

@ -1,44 +0,0 @@
/*
* exit.c
*
* Description:
* This translation unit implements routines associated with exiting from
* a thread.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
#if ! defined(_UWIN) && ! defined(WINCE)
# include <process.h>
#endif
#include "pthread_exit.c"

39
3rdparty/pthreads4w/fork.c vendored
View File

@ -1,39 +0,0 @@
/*
* fork.c
*
* Description:
* Implementation of fork() for POSIX threads.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"

107
3rdparty/pthreads4w/global.c vendored
View File

@ -1,107 +0,0 @@
/*
* global.c
*
* Description:
* This translation unit instantiates data associated with the implementation
* as a whole.
*
* --------------------------------------------------------------------------
*
* 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
*/
#include "pthread.h"
#include "implement.h"
int ptw32_processInitialized = PTW32_FALSE;
ptw32_thread_t * ptw32_threadReuseTop = PTW32_THREAD_REUSE_EMPTY;
ptw32_thread_t * ptw32_threadReuseBottom = PTW32_THREAD_REUSE_EMPTY;
pthread_key_t ptw32_selfThreadKey = NULL;
pthread_key_t ptw32_cleanupKey = NULL;
pthread_cond_t ptw32_cond_list_head = NULL;
pthread_cond_t ptw32_cond_list_tail = NULL;
int ptw32_concurrency = 0;
/* What features have been auto-detected */
int ptw32_features = 0;
/*
* Global [process wide] thread sequence Number
*/
unsigned __int64 ptw32_threadSeqNumber = 0;
/*
* Function pointer to QueueUserAPCEx if it exists, otherwise
* it will be set at runtime to a substitute routine which cannot unblock
* blocked threads.
*/
DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD) = NULL;
/*
* Global lock for managing pthread_t struct reuse.
*/
ptw32_mcs_lock_t ptw32_thread_reuse_lock = 0;
/*
* Global lock for testing internal state of statically declared mutexes.
*/
ptw32_mcs_lock_t ptw32_mutex_test_init_lock = 0;
/*
* Global lock for testing internal state of PTHREAD_COND_INITIALIZER
* created condition variables.
*/
ptw32_mcs_lock_t ptw32_cond_test_init_lock = 0;
/*
* Global lock for testing internal state of PTHREAD_RWLOCK_INITIALIZER
* created read/write locks.
*/
ptw32_mcs_lock_t ptw32_rwlock_test_init_lock = 0;
/*
* Global lock for testing internal state of PTHREAD_SPINLOCK_INITIALIZER
* created spin locks.
*/
ptw32_mcs_lock_t ptw32_spinlock_test_init_lock = 0;
/*
* Global lock for condition variable linked list. The list exists
* to wake up CVs when a WM_TIMECHANGE message arrives. See
* w32_TimeChangeHandler.c.
*/
ptw32_mcs_lock_t ptw32_cond_list_lock = 0;
#if defined(_UWIN)
/*
* Keep a count of the number of threads.
*/
int pthread_count = 0;
#endif

943
3rdparty/pthreads4w/implement.h vendored
View File

@ -1,943 +0,0 @@
/*
* implement.h
*
* Definitions that don't need to be public.
*
* Keeps all the internals out of pthread.h
*
* --------------------------------------------------------------------------
*
* Pthreads-win32 - POSIX Threads Library for Win32
* Copyright(C) 1998 John E. Bossom
* Copyright(C) 1999,2005 Pthreads-win32 contributors
*
* Contact Email: Ross.Johnson@homemail.com.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(_IMPLEMENT_H)
#define _IMPLEMENT_H
#if !defined(_WIN32_WINNT)
#define _WIN32_WINNT 0x0400
#endif
#include <windows.h>
/*
* In case windows.h doesn't define it (e.g. WinCE perhaps)
*/
#if defined(WINCE)
typedef VOID (APIENTRY *PAPCFUNC)(DWORD dwParam);
#endif
/*
* note: ETIMEDOUT is correctly defined in winsock.h
*/
#include <winsock.h>
/*
* In case ETIMEDOUT hasn't been defined above somehow.
*/
#if !defined(ETIMEDOUT)
# define ETIMEDOUT 10060 /* This is the value in winsock.h. */
#endif
#if !defined(malloc)
#include <malloc.h>
#endif
#if defined(__CLEANUP_C)
# include <setjmp.h>
#endif
#if !defined(INT_MAX)
#include <limits.h>
#endif
/* use local include files during development */
#include "semaphore.h"
#include "sched.h"
#if defined(HAVE_C_INLINE) || defined(__cplusplus)
#define INLINE inline
#else
#define INLINE
#endif
#if defined(_MSC_VER) && _MSC_VER < 1300
/*
* MSVC 6 does not use the "volatile" qualifier
*/
#define PTW32_INTERLOCKED_VOLATILE
#else
#define PTW32_INTERLOCKED_VOLATILE volatile
#endif
#define PTW32_INTERLOCKED_LONG long
#define PTW32_INTERLOCKED_SIZE size_t
#define PTW32_INTERLOCKED_PVOID PVOID
#define PTW32_INTERLOCKED_LONGPTR PTW32_INTERLOCKED_VOLATILE long*
#define PTW32_INTERLOCKED_SIZEPTR PTW32_INTERLOCKED_VOLATILE size_t*
#define PTW32_INTERLOCKED_PVOID_PTR PTW32_INTERLOCKED_VOLATILE PVOID*
#if defined(__MINGW64__) || defined(__MINGW32__)
# include <stdint.h>
#elif defined(__BORLANDC__)
# define int64_t ULONGLONG
#else
# define int64_t _int64
# if defined(_MSC_VER) && _MSC_VER < 1300
typedef long intptr_t;
# endif
#endif
typedef enum
{
/*
* This enumeration represents the state of the thread;
* The thread is still "alive" if the numeric value of the
* state is greater or equal "PThreadStateRunning".
*/
PThreadStateInitial = 0, /* Thread not running */
PThreadStateRunning, /* Thread alive & kicking */
PThreadStateSuspended, /* Thread alive but suspended */
PThreadStateCancelPending, /* Thread alive but */
/* has cancelation pending. */
PThreadStateCanceling, /* Thread alive but is */
/* in the process of terminating */
/* due to a cancellation request */
PThreadStateExiting, /* Thread alive but exiting */
/* due to an exception */
PThreadStateLast, /* All handlers have been run and now */
/* final cleanup can be done. */
PThreadStateReuse /* In reuse pool. */
}
PThreadState;
typedef struct ptw32_mcs_node_t_ ptw32_mcs_local_node_t;
typedef struct ptw32_mcs_node_t_* ptw32_mcs_lock_t;
typedef struct ptw32_robust_node_t_ ptw32_robust_node_t;
typedef struct ptw32_thread_t_ ptw32_thread_t;
struct ptw32_thread_t_
{
unsigned __int64 seqNumber; /* Process-unique thread sequence number */
HANDLE threadH; /* Win32 thread handle - POSIX thread is invalid if threadH == 0 */
pthread_t ptHandle; /* This thread's permanent pthread_t handle */
ptw32_thread_t * prevReuse; /* Links threads on reuse stack */
volatile PThreadState state;
ptw32_mcs_lock_t threadLock; /* Used for serialised access to public thread state */
ptw32_mcs_lock_t stateLock; /* Used for async-cancel safety */
HANDLE cancelEvent;
void *exitStatus;
void *parms;
void *keys;
void *nextAssoc;
#if defined(__CLEANUP_C)
jmp_buf start_mark; /* Jump buffer follows void* so should be aligned */
#endif /* __CLEANUP_C */
#if defined(HAVE_SIGSET_T)
sigset_t sigmask;
#endif /* HAVE_SIGSET_T */
ptw32_mcs_lock_t
robustMxListLock; /* robustMxList lock */
ptw32_robust_node_t*
robustMxList; /* List of currenty held robust mutexes */
int ptErrno;
int detachState;
int sched_priority; /* As set, not as currently is */
int cancelState;
int cancelType;
int implicit:1;
DWORD thread; /* Win32 thread ID */
#if defined(_UWIN)
DWORD dummy[5];
#endif
size_t align; /* Force alignment if this struct is packed */
};
/*
* Special value to mark attribute objects as valid.
*/
#define PTW32_ATTR_VALID ((unsigned long) 0xC4C0FFEE)
struct pthread_attr_t_
{
unsigned long valid;
void *stackaddr;
size_t stacksize;
int detachstate;
struct sched_param param;
int inheritsched;
int contentionscope;
#if defined(HAVE_SIGSET_T)
sigset_t sigmask;
#endif /* HAVE_SIGSET_T */
};
/*
* ====================
* ====================
* Semaphores, Mutexes and Condition Variables
* ====================
* ====================
*/
struct sem_t_
{
int value;
pthread_mutex_t lock;
HANDLE sem;
#if defined(NEED_SEM)
int leftToUnblock;
#endif
};
#define PTW32_OBJECT_AUTO_INIT ((void *)(size_t) -1)
#define PTW32_OBJECT_INVALID NULL
struct pthread_mutex_t_
{
LONG lock_idx; /* Provides exclusive access to mutex state
via the Interlocked* mechanism.
0: unlocked/free.
1: locked - no other waiters.
-1: locked - with possible other waiters.
*/
int recursive_count; /* Number of unlocks a thread needs to perform
before the lock is released (recursive
mutexes only). */
int kind; /* Mutex type. */
pthread_t ownerThread;
HANDLE event; /* Mutex release notification to waiting
threads. */
ptw32_robust_node_t*
robustNode; /* Extra state for robust mutexes */
};
enum ptw32_robust_state_t_
{
PTW32_ROBUST_CONSISTENT,
PTW32_ROBUST_INCONSISTENT,
PTW32_ROBUST_NOTRECOVERABLE
};
typedef enum ptw32_robust_state_t_ ptw32_robust_state_t;
/*
* Node used to manage per-thread lists of currently-held robust mutexes.
*/
struct ptw32_robust_node_t_
{
pthread_mutex_t mx;
ptw32_robust_state_t stateInconsistent;
ptw32_robust_node_t* prev;
ptw32_robust_node_t* next;
};
struct pthread_mutexattr_t_
{
int pshared;
int kind;
int robustness;
};
/*
* Possible values, other than PTW32_OBJECT_INVALID,
* for the "interlock" element in a spinlock.
*
* In this implementation, when a spinlock is initialised,
* the number of cpus available to the process is checked.
* If there is only one cpu then "interlock" is set equal to
* PTW32_SPIN_USE_MUTEX and u.mutex is an initialised mutex.
* If the number of cpus is greater than 1 then "interlock"
* is set equal to PTW32_SPIN_UNLOCKED and the number is
* stored in u.cpus. This arrangement allows the spinlock
* routines to attempt an InterlockedCompareExchange on "interlock"
* immediately and, if that fails, to try the inferior mutex.
*
* "u.cpus" isn't used for anything yet, but could be used at
* some point to optimise spinlock behaviour.
*/
#define PTW32_SPIN_INVALID (0)
#define PTW32_SPIN_UNLOCKED (1)
#define PTW32_SPIN_LOCKED (2)
#define PTW32_SPIN_USE_MUTEX (3)
struct pthread_spinlock_t_
{
long interlock; /* Locking element for multi-cpus. */
union
{
int cpus; /* No. of cpus if multi cpus, or */
pthread_mutex_t mutex; /* mutex if single cpu. */
} u;
};
/*
* MCS lock queue node - see ptw32_MCS_lock.c
*/
struct ptw32_mcs_node_t_
{
struct ptw32_mcs_node_t_ **lock; /* ptr to tail of queue */
struct ptw32_mcs_node_t_ *next; /* ptr to successor in queue */
HANDLE readyFlag; /* set after lock is released by
predecessor */
HANDLE nextFlag; /* set after 'next' ptr is set by
successor */
};
struct pthread_barrier_t_
{
unsigned int nCurrentBarrierHeight;
unsigned int nInitialBarrierHeight;
int pshared;
sem_t semBarrierBreeched;
ptw32_mcs_lock_t lock;
ptw32_mcs_local_node_t proxynode;
};
struct pthread_barrierattr_t_
{
int pshared;
};
struct pthread_key_t_
{
DWORD key;
void (PTW32_CDECL *destructor) (void *);
ptw32_mcs_lock_t keyLock;
void *threads;
};
typedef struct ThreadParms ThreadParms;
struct ThreadParms
{
pthread_t tid;
void *(PTW32_CDECL *start) (void *);
void *arg;
};
struct pthread_cond_t_
{
long nWaitersBlocked; /* Number of threads blocked */
long nWaitersGone; /* Number of threads timed out */
long nWaitersToUnblock; /* Number of threads to unblock */
sem_t semBlockQueue; /* Queue up threads waiting for the */
/* condition to become signalled */
sem_t semBlockLock; /* Semaphore that guards access to */
/* | waiters blocked count/block queue */
/* +-> Mandatory Sync.LEVEL-1 */
pthread_mutex_t mtxUnblockLock; /* Mutex that guards access to */
/* | waiters (to)unblock(ed) counts */
/* +-> Optional* Sync.LEVEL-2 */
pthread_cond_t next; /* Doubly linked list */
pthread_cond_t prev;
};
struct pthread_condattr_t_
{
int pshared;
};
#define PTW32_RWLOCK_MAGIC 0xfacade2
struct pthread_rwlock_t_
{
pthread_mutex_t mtxExclusiveAccess;
pthread_mutex_t mtxSharedAccessCompleted;
pthread_cond_t cndSharedAccessCompleted;
int nSharedAccessCount;
int nExclusiveAccessCount;
int nCompletedSharedAccessCount;
int nMagic;
};
struct pthread_rwlockattr_t_
{
int pshared;
};
typedef struct ThreadKeyAssoc ThreadKeyAssoc;
struct ThreadKeyAssoc
{
/*
* Purpose:
* This structure creates an association between a thread and a key.
* It is used to implement the implicit invocation of a user defined
* destroy routine for thread specific data registered by a user upon
* exiting a thread.
*
* Graphically, the arrangement is as follows, where:
*
* K - Key with destructor
* (head of chain is key->threads)
* T - Thread that has called pthread_setspecific(Kn)
* (head of chain is thread->keys)
* A - Association. Each association is a node at the
* intersection of two doubly-linked lists.
*
* T1 T2 T3
* | | |
* | | |
* K1 -----+-----A-----A----->
* | | |
* | | |
* K2 -----A-----A-----+----->
* | | |
* | | |
* K3 -----A-----+-----A----->
* | | |
* | | |
* V V V
*
* Access to the association is guarded by two locks: the key's
* general lock (guarding the row) and the thread's general
* lock (guarding the column). This avoids the need for a
* dedicated lock for each association, which not only consumes
* more handles but requires that the lock resources persist
* until both the key is deleted and the thread has called the
* destructor. The two-lock arrangement allows those resources
* to be freed as soon as either thread or key is concluded.
*
* To avoid deadlock, whenever both locks are required both the
* key and thread locks are acquired consistently in the order
* "key lock then thread lock". An exception to this exists
* when a thread calls the destructors, however, this is done
* carefully (but inelegantly) to avoid deadlock.
*
* An association is created when a thread first calls
* pthread_setspecific() on a key that has a specified
* destructor.
*
* An association is destroyed either immediately after the
* thread calls the key destructor function on thread exit, or
* when the key is deleted.
*
* Attributes:
* thread
* reference to the thread that owns the
* association. This is actually the pointer to the
* thread struct itself. Since the association is
* destroyed before the thread exits, this can never
* point to a different logical thread to the one that
* created the assoc, i.e. after thread struct reuse.
*
* key
* reference to the key that owns the association.
*
* nextKey
* The pthread_t->keys attribute is the head of a
* chain of associations that runs through the nextKey
* link. This chain provides the 1 to many relationship
* between a pthread_t and all pthread_key_t on which
* it called pthread_setspecific.
*
* prevKey
* Similarly.
*
* nextThread
* The pthread_key_t->threads attribute is the head of
* a chain of associations that runs through the
* nextThreads link. This chain provides the 1 to many
* relationship between a pthread_key_t and all the
* PThreads that have called pthread_setspecific for
* this pthread_key_t.
*
* prevThread
* Similarly.
*
* Notes:
* 1) As soon as either the key or the thread is no longer
* referencing the association, it can be destroyed. The
* association will be removed from both chains.
*
* 2) Under WIN32, an association is only created by
* pthread_setspecific if the user provided a
* destroyRoutine when they created the key.
*
*
*/
ptw32_thread_t * thread;
pthread_key_t key;
ThreadKeyAssoc *nextKey;
ThreadKeyAssoc *nextThread;
ThreadKeyAssoc *prevKey;
ThreadKeyAssoc *prevThread;
};
#if defined(__CLEANUP_SEH)
/*
* --------------------------------------------------------------
* MAKE_SOFTWARE_EXCEPTION
* This macro constructs a software exception code following
* the same format as the standard Win32 error codes as defined
* in WINERROR.H
* Values are 32 bit values laid out as follows:
*
* 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
* +---+-+-+-----------------------+-------------------------------+
* |Sev|C|R| Facility | Code |
* +---+-+-+-----------------------+-------------------------------+
*
* Severity Values:
*/
#define SE_SUCCESS 0x00
#define SE_INFORMATION 0x01
#define SE_WARNING 0x02
#define SE_ERROR 0x03
#define MAKE_SOFTWARE_EXCEPTION( _severity, _facility, _exception ) \
( (DWORD) ( ( (_severity) << 30 ) | /* Severity code */ \
( 1 << 29 ) | /* MS=0, User=1 */ \
( 0 << 28 ) | /* Reserved */ \
( (_facility) << 16 ) | /* Facility Code */ \
( (_exception) << 0 ) /* Exception Code */ \
) )
/*
* We choose one specific Facility/Error code combination to
* identify our software exceptions vs. WIN32 exceptions.
* We store our actual component and error code within
* the optional information array.
*/
#define EXCEPTION_PTW32_SERVICES \
MAKE_SOFTWARE_EXCEPTION( SE_ERROR, \
PTW32_SERVICES_FACILITY, \
PTW32_SERVICES_ERROR )
#define PTW32_SERVICES_FACILITY 0xBAD
#define PTW32_SERVICES_ERROR 0xDEED
#endif /* __CLEANUP_SEH */
/*
* Services available through EXCEPTION_PTW32_SERVICES
* and also used [as parameters to ptw32_throw()] as
* generic exception selectors.
*/
#define PTW32_EPS_EXIT (1)
#define PTW32_EPS_CANCEL (2)
/* Useful macros */
#define PTW32_MAX(a,b) ((a)<(b)?(b):(a))
#define PTW32_MIN(a,b) ((a)>(b)?(b):(a))
/* Declared in pthread_cancel.c */
extern DWORD (*ptw32_register_cancelation) (PAPCFUNC, HANDLE, DWORD);
/* Thread Reuse stack bottom marker. Must not be NULL or any valid pointer to memory. */
#define PTW32_THREAD_REUSE_EMPTY ((ptw32_thread_t *)(size_t) 1)
extern int ptw32_processInitialized;
extern ptw32_thread_t * ptw32_threadReuseTop;
extern ptw32_thread_t * ptw32_threadReuseBottom;
extern pthread_key_t ptw32_selfThreadKey;
extern pthread_key_t ptw32_cleanupKey;
extern pthread_cond_t ptw32_cond_list_head;
extern pthread_cond_t ptw32_cond_list_tail;
extern int ptw32_mutex_default_kind;
extern unsigned __int64 ptw32_threadSeqNumber;
extern int ptw32_concurrency;
extern int ptw32_features;
extern ptw32_mcs_lock_t ptw32_thread_reuse_lock;
extern ptw32_mcs_lock_t ptw32_mutex_test_init_lock;
extern ptw32_mcs_lock_t ptw32_cond_list_lock;
extern ptw32_mcs_lock_t ptw32_cond_test_init_lock;
extern ptw32_mcs_lock_t ptw32_rwlock_test_init_lock;
extern ptw32_mcs_lock_t ptw32_spinlock_test_init_lock;
#if defined(_UWIN)
extern int pthread_count;
#endif
#if defined(__cplusplus)
extern "C"
{
#endif /* __cplusplus */
/*
* =====================
* =====================
* Forward Declarations
* =====================
* =====================
*/
int ptw32_is_attr (const pthread_attr_t * attr);
int ptw32_cond_check_need_init (pthread_cond_t * cond);
int ptw32_mutex_check_need_init (pthread_mutex_t * mutex);
int ptw32_rwlock_check_need_init (pthread_rwlock_t * rwlock);
int ptw32_robust_mutex_inherit(pthread_mutex_t * mutex);
void ptw32_robust_mutex_add(pthread_mutex_t* mutex, pthread_t self);
void ptw32_robust_mutex_remove(pthread_mutex_t* mutex, ptw32_thread_t* otp);
DWORD
ptw32_RegisterCancelation (PAPCFUNC callback,
HANDLE threadH, DWORD callback_arg);
int ptw32_processInitialize (void);
void ptw32_processTerminate (void);
void ptw32_threadDestroy (pthread_t tid);
void ptw32_pop_cleanup_all (int execute);
pthread_t ptw32_new (void);
pthread_t ptw32_threadReusePop (void);
void ptw32_threadReusePush (pthread_t thread);
int ptw32_getprocessors (int *count);
int ptw32_setthreadpriority (pthread_t thread, int policy, int priority);
void ptw32_rwlock_cancelwrwait (void *arg);
#if ! (defined (__MINGW64__) || defined(__MINGW32__)) || (defined(__MSVCRT__) && ! defined(__DMC__))
unsigned __stdcall
#else
void
#endif
ptw32_threadStart (void *vthreadParms);
void ptw32_callUserDestroyRoutines (pthread_t thread);
int ptw32_tkAssocCreate (ptw32_thread_t * thread, pthread_key_t key);
void ptw32_tkAssocDestroy (ThreadKeyAssoc * assoc);
int ptw32_semwait (sem_t * sem);
DWORD ptw32_relmillisecs (const struct timespec * abstime);
void ptw32_mcs_lock_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
int ptw32_mcs_lock_try_acquire (ptw32_mcs_lock_t * lock, ptw32_mcs_local_node_t * node);
void ptw32_mcs_lock_release (ptw32_mcs_local_node_t * node);
void ptw32_mcs_node_transfer (ptw32_mcs_local_node_t * new_node, ptw32_mcs_local_node_t * old_node);
#if defined(NEED_FTIME)
void ptw32_timespec_to_filetime (const struct timespec *ts, FILETIME * ft);
void ptw32_filetime_to_timespec (const FILETIME * ft, struct timespec *ts);
#endif
/* Declared in misc.c */
#if defined(NEED_CALLOC)
#define calloc(n, s) ptw32_calloc(n, s)
void *ptw32_calloc (size_t n, size_t s);
#endif
/* Declared in private.c */
#if defined(_MSC_VER)
/*
* Ignore the warning:
* "C++ exception specification ignored except to indicate that
* the function is not __declspec(nothrow)."
*/
#pragma warning(disable:4290)
#endif
void ptw32_throw (DWORD exception)
#if defined(__CLEANUP_CXX)
throw(ptw32_exception_cancel,ptw32_exception_exit)
#endif
;
#if defined(__cplusplus)
}
#endif /* __cplusplus */
#if defined(_UWIN_)
# if defined(_MT)
# if defined(__cplusplus)
extern "C"
{
# endif
_CRTIMP unsigned long __cdecl _beginthread (void (__cdecl *) (void *),
unsigned, void *);
_CRTIMP void __cdecl _endthread (void);
_CRTIMP unsigned long __cdecl _beginthreadex (void *, unsigned,
unsigned (__stdcall *) (void *),
void *, unsigned, unsigned *);
_CRTIMP void __cdecl _endthreadex (unsigned);
# if defined(__cplusplus)
}
# endif
# endif
#else
# include <process.h>
# endif
/*
* Use intrinsic versions wherever possible. VC will do this
* automatically where possible and GCC define these if available:
* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1
* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2
* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16
*
* The full set of Interlocked intrinsics in GCC are (check versions):
* type __sync_fetch_and_add (type *ptr, type value, ...)
* type __sync_fetch_and_sub (type *ptr, type value, ...)
* type __sync_fetch_and_or (type *ptr, type value, ...)
* type __sync_fetch_and_and (type *ptr, type value, ...)
* type __sync_fetch_and_xor (type *ptr, type value, ...)
* type __sync_fetch_and_nand (type *ptr, type value, ...)
* type __sync_add_and_fetch (type *ptr, type value, ...)
* type __sync_sub_and_fetch (type *ptr, type value, ...)
* type __sync_or_and_fetch (type *ptr, type value, ...)
* type __sync_and_and_fetch (type *ptr, type value, ...)
* type __sync_xor_and_fetch (type *ptr, type value, ...)
* type __sync_nand_and_fetch (type *ptr, type value, ...)
* bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...)
* type __sync_val_compare_and_swap (type *ptr, type oldval type newval, ...)
* __sync_synchronize (...) // Full memory barrier
* type __sync_lock_test_and_set (type *ptr, type value, ...) // Acquire barrier
* void __sync_lock_release (type *ptr, ...) // Release barrier
*
* These are all overloaded and take 1,2,4,8 byte scalar or pointer types.
*
* The above aren't available in Mingw32 as of gcc 4.5.2 so define our own.
*/
#if defined(__GNUC__)
# if defined(_WIN64)
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64(location, value, comparand) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"cmpxchgq %2,(%1)" \
:"=a" (_result) \
:"r" (location), "r" (value), "a" (comparand) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_EXCHANGE_64(location, value) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"xchgq %0,(%1)" \
:"=r" (_result) \
:"r" (location), "0" (value) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_EXCHANGE_ADD_64(location, value) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddq %0,(%1)" \
:"=r" (_result) \
:"r" (location), "0" (value) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_INCREMENT_64(location) \
({ \
PTW32_INTERLOCKED_LONG _temp = 1; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddq %0,(%1)" \
:"+r" (_temp) \
:"r" (location) \
:"memory", "cc"); \
++_temp; \
})
# define PTW32_INTERLOCKED_DECREMENT_64(location) \
({ \
PTW32_INTERLOCKED_LONG _temp = -1; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddq %2,(%1)" \
:"+r" (_temp) \
:"r" (location) \
:"memory", "cc"); \
--_temp; \
})
#endif
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"cmpxchgl %2,(%1)" \
:"=a" (_result) \
:"r" (location), "r" (value), "a" (comparand) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_EXCHANGE_LONG(location, value) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"xchgl %0,(%1)" \
:"=r" (_result) \
:"r" (location), "0" (value) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG(location, value) \
({ \
__typeof (value) _result; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddl %0,(%1)" \
:"=r" (_result) \
:"r" (location), "0" (value) \
:"memory", "cc"); \
_result; \
})
# define PTW32_INTERLOCKED_INCREMENT_LONG(location) \
({ \
PTW32_INTERLOCKED_LONG _temp = 1; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddl %0,(%1)" \
:"+r" (_temp) \
:"r" (location) \
:"memory", "cc"); \
++_temp; \
})
# define PTW32_INTERLOCKED_DECREMENT_LONG(location) \
({ \
PTW32_INTERLOCKED_LONG _temp = -1; \
__asm__ __volatile__ \
( \
"lock\n\t" \
"xaddl %0,(%1)" \
:"+r" (_temp) \
:"r" (location) \
:"memory", "cc"); \
--_temp; \
})
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR(location, value, comparand) \
PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
(PTW32_INTERLOCKED_SIZE)value, \
(PTW32_INTERLOCKED_SIZE)comparand)
# define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
PTW32_INTERLOCKED_EXCHANGE_SIZE((PTW32_INTERLOCKED_SIZEPTR)location, \
(PTW32_INTERLOCKED_SIZE)value)
#else
# if defined(_WIN64)
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_64 InterlockedCompareExchange64
# define PTW32_INTERLOCKED_EXCHANGE_64 InterlockedExchange64
# define PTW32_INTERLOCKED_EXCHANGE_ADD_64 InterlockedExchangeAdd64
# define PTW32_INTERLOCKED_INCREMENT_64 InterlockedIncrement64
# define PTW32_INTERLOCKED_DECREMENT_64 InterlockedDecrement64
# endif
# if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG(location, value, comparand) \
((LONG)InterlockedCompareExchange((PVOID *)(location), (PVOID)(value), (PVOID)(comparand)))
# else
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG InterlockedCompareExchange
# endif
# define PTW32_INTERLOCKED_EXCHANGE_LONG InterlockedExchange
# define PTW32_INTERLOCKED_EXCHANGE_ADD_LONG InterlockedExchangeAdd
# define PTW32_INTERLOCKED_INCREMENT_LONG InterlockedIncrement
# define PTW32_INTERLOCKED_DECREMENT_LONG InterlockedDecrement
# if defined(_MSC_VER) && _MSC_VER < 1300 && !defined(_WIN64) /* MSVC 6 */
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchange
# define PTW32_INTERLOCKED_EXCHANGE_PTR(location, value) \
((PVOID)InterlockedExchange((LPLONG)(location), (LONG)(value)))
# else
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_PTR InterlockedCompareExchangePointer
# define PTW32_INTERLOCKED_EXCHANGE_PTR InterlockedExchangePointer
# endif
#endif
#if defined(_WIN64)
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE PTW32_INTERLOCKED_COMPARE_EXCHANGE_64
# define PTW32_INTERLOCKED_EXCHANGE_SIZE PTW32_INTERLOCKED_EXCHANGE_64
# define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE PTW32_INTERLOCKED_EXCHANGE_ADD_64
# define PTW32_INTERLOCKED_INCREMENT_SIZE PTW32_INTERLOCKED_INCREMENT_64
# define PTW32_INTERLOCKED_DECREMENT_SIZE PTW32_INTERLOCKED_DECREMENT_64
#else
# define PTW32_INTERLOCKED_COMPARE_EXCHANGE_SIZE PTW32_INTERLOCKED_COMPARE_EXCHANGE_LONG
# define PTW32_INTERLOCKED_EXCHANGE_SIZE PTW32_INTERLOCKED_EXCHANGE_LONG
# define PTW32_INTERLOCKED_EXCHANGE_ADD_SIZE PTW32_INTERLOCKED_EXCHANGE_ADD_LONG
# define PTW32_INTERLOCKED_INCREMENT_SIZE PTW32_INTERLOCKED_INCREMENT_LONG
# define PTW32_INTERLOCKED_DECREMENT_SIZE PTW32_INTERLOCKED_DECREMENT_LONG
#endif
#if defined(NEED_CREATETHREAD)
/*
* Macro uses args so we can cast start_proc to LPTHREAD_START_ROUTINE
* in order to avoid warnings because of return type
*/
#define _beginthreadex(security, \
stack_size, \
start_proc, \
arg, \
flags, \
pid) \
CreateThread(security, \
stack_size, \
(LPTHREAD_START_ROUTINE) start_proc, \
arg, \
flags, \
pid)
#define _endthreadex ExitThread
#endif /* NEED_CREATETHREAD */
#endif /* _IMPLEMENT_H */

1387
3rdparty/pthreads4w/include/pthread.h vendored
View File

File diff suppressed because it is too large Load Diff

183
3rdparty/pthreads4w/include/sched.h vendored
View File

@ -1,183 +0,0 @@
/*
* 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 <errno.h>
#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 <sys/types.h>
/* Required by Unix 98 */
# include <time.h>
# 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 */

169
3rdparty/pthreads4w/include/semaphore.h vendored
View File

@ -1,169 +0,0 @@
/*
* Module: semaphore.h
*
* Purpose:
* Semaphores aren't actually part of the PThreads standard.
* They are defined by the POSIX Standard:
*
* 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( SEMAPHORE_H )
#define SEMAPHORE_H
#undef PTW32_SEMAPHORE_LEVEL
#if defined(_POSIX_SOURCE)
#define PTW32_SEMAPHORE_LEVEL 0
/* Early POSIX */
#endif
#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
#undef PTW32_SEMAPHORE_LEVEL
#define PTW32_SEMAPHORE_LEVEL 1
/* Include 1b, 1c and 1d */
#endif
#if defined(INCLUDE_NP)
#undef PTW32_SEMAPHORE_LEVEL
#define PTW32_SEMAPHORE_LEVEL 2
/* Include Non-Portable extensions */
#endif
#define PTW32_SEMAPHORE_LEVEL_MAX 3
#if !defined(PTW32_SEMAPHORE_LEVEL)
#define PTW32_SEMAPHORE_LEVEL PTW32_SEMAPHORE_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_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX
#if defined(NEED_ERRNO)
#include "need_errno.h"
#else
#include <errno.h>
#endif
#endif /* PTW32_SEMAPHORE_LEVEL >= PTW32_SEMAPHORE_LEVEL_MAX */
#define _POSIX_SEMAPHORES
#if defined(__cplusplus)
extern "C"
{
#endif /* __cplusplus */
#if !defined(HAVE_MODE_T)
typedef unsigned int mode_t;
#endif
typedef struct sem_t_ * sem_t;
PTW32_DLLPORT int __cdecl sem_init (sem_t * sem,
int pshared,
unsigned int value);
PTW32_DLLPORT int __cdecl sem_destroy (sem_t * sem);
PTW32_DLLPORT int __cdecl sem_trywait (sem_t * sem);
PTW32_DLLPORT int __cdecl sem_wait (sem_t * sem);
PTW32_DLLPORT int __cdecl sem_timedwait (sem_t * sem,
const struct timespec * abstime);
PTW32_DLLPORT int __cdecl sem_post (sem_t * sem);
PTW32_DLLPORT int __cdecl sem_post_multiple (sem_t * sem,
int count);
PTW32_DLLPORT int __cdecl sem_open (const char * name,
int oflag,
mode_t mode,
unsigned int value);
PTW32_DLLPORT int __cdecl sem_close (sem_t * sem);
PTW32_DLLPORT int __cdecl sem_unlink (const char * name);
PTW32_DLLPORT int __cdecl sem_getvalue (sem_t * sem,
int * sval);
#if defined(__cplusplus)
} /* End of extern "C" */
#endif /* __cplusplus */
#undef PTW32_SEMAPHORE_LEVEL
#undef PTW32_SEMAPHORE_LEVEL_MAX
#endif /* !SEMAPHORE_H */

74
3rdparty/pthreads4w/manual/ChangeLog vendored
View File

@ -1,74 +0,0 @@
2011-03-26 Ross Johnson <ross at homemail dot com dot au>
* pthread_nutex_init.html (robust mutexes): Added
descriptions for newly implemented interface.
* pthread_mutexattr_init.html (robust mutexes): Likewise.
* pthread_getsequence_np.html: New.
* index.html: Updated.
2008-06-30 Ross Johnson <ross at callisto.canberra.edu.au>
* pthread_setschedparam.html: Fix "see also" links.
2005-05-06 Ross Johnson <ross at callisto.canberra.edu.au>
* PortabilityIssues.html: Was nonPortableIssues.html.
* index.html: Updated; add table of contents at top.
* *.html: Add Pthreads-win32 header info; add link back to the
index page 'index.html'.
2005-05-06 Ross Johnson <ross at callisto.canberra.edu.au>
* index.html: New.
* nonPortableIssues.html: New.
* pthread_attr_init.html: New.
* pthread_attr_setstackaddr.html: New.
* pthread_attr_setstacksize.html: New.
* pthread_barrierattr_init.html: New.
* pthread_barrierattr_setpshared.html: New.
* pthread_barrier_init.html: New.
* pthread_barrier_wait.html: New.
* pthreadCancelableWait.html: New.
* pthread_cancel.html: New.
* pthread_cleanup_push.html: New.
* pthread_condattr_init.html: New.
* pthread_condattr_setpshared.html: New.
* pthread_cond_init.html: New.
* pthread_create.html: New.
* pthread_delay_np.html: New.
* pthread_detach.html: New.
* pthread_equal.html: New.
* pthread_exit.html: New.
* pthread_getw32threadhandle_np.html: New.
* pthread_join.html: New.
* pthread_key_create.html: New.
* pthread_kill.html: New.
* pthread_mutexattr_init.html: New.
* pthread_mutexattr_setpshared.html: New.
* pthread_mutex_init.html: New.
* pthread_num_processors_np.html: New.
* pthread_once.html: New.
* pthread_rwlockattr_init.html: New.
* pthread_rwlockattr_setpshared.html: New.
* pthread_rwlock_init.html: New.
* pthread_rwlock_rdlock.html: New.
* pthread_rwlock_timedrdlock.html: New.
* pthread_rwlock_timedwrlock.html: New.
* pthread_rwlock_unlock.html: New.
* pthread_rwlock_wrlock.html: New.
* pthread_self.html: New.
* pthread_setcancelstate.html: New.
* pthread_setcanceltype.html: New.
* pthread_setconcurrency.html: New.
* pthread_setschedparam.html: New.
* pthread_spin_init.html: New.
* pthread_spin_lock.html: New.
* pthread_spin_unlock.html: New.
* pthread_timechange_handler_np.html: New.
* pthread_win32_attach_detach_np.html: New.
* pthread_win32_test_features_np.html: New.
* sched_get_priority_max.html: New.
* sched_getscheduler.html: New.
* sched_setscheduler.html: New.
* sched_yield.html: New.
* sem_init.html: New.

718
3rdparty/pthreads4w/manual/PortabilityIssues.html vendored
View File

@ -1,718 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PORTABILITYISSUES manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050506;11580000">
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<H4><A HREF="#toc">Table of Contents</A></H4>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">Portability issues</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>Thread priority</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<H3>Thread priority</H3>
<P STYLE="margin-left: 2cm">POSIX defines a single contiguous range
of numbers that determine a thread's priority. Win32 defines priority
classes - and priority levels relative to these classes. Classes are
simply priority base levels that the defined priority levels are
relative to such that, changing a process's priority class will
change the priority of all of it's threads, while the threads retain
the same relativity to each other.</P>
<P STYLE="margin-left: 2cm">A Win32 system defines a single
contiguous monotonic range of values that define system priority
levels, just like POSIX. However, Win32 restricts individual threads
to a subset of this range on a per-process basis.</P>
<P STYLE="margin-left: 2cm">The following table shows the base
priority levels for combinations of priority class and priority value
in Win32.</P>
<DL>
<DL>
<DD>
<TABLE WIDTH=742 BORDER=0 CELLPADDING=0 CELLSPACING=0 STYLE="page-break-inside: avoid">
<COL WIDTH=50>
<COL WIDTH=356>
<COL WIDTH=336>
<THEAD>
<TR VALIGN=TOP>
<TD WIDTH=50>
<P ALIGN=CENTER><BR>
</P>
</TD>
<TD WIDTH=356>
<P ALIGN=LEFT><B>Process Priority Class</B></P>
</TD>
<TD WIDTH=336>
<P ALIGN=LEFT><B>Thread Priority Level</B></P>
</TD>
</TR>
</THEAD>
<TBODY>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
<P ALIGN=CENTER>1</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
<P ALIGN=CENTER>1</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
<P ALIGN=CENTER>1</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
<P ALIGN=CENTER>1</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="1" SDNUM="3081;">
<P ALIGN=CENTER>1</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="2" SDNUM="3081;">
<P ALIGN=CENTER>2</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="3" SDNUM="3081;">
<P ALIGN=CENTER>3</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
<P ALIGN=CENTER>4</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
<P ALIGN=CENTER>4</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
<P ALIGN=CENTER>5</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
<P ALIGN=CENTER>5</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
<P ALIGN=CENTER>5</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
<P ALIGN=CENTER>6</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
<P ALIGN=CENTER>6</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
<P ALIGN=CENTER>6</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
<P ALIGN=CENTER>7</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
<P ALIGN=CENTER>7</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Background NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="7" SDNUM="3081;">
<P ALIGN=CENTER>7</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
<P ALIGN=CENTER>8</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
<P ALIGN=CENTER>8</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
<P ALIGN=CENTER>8</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="8" SDNUM="3081;">
<P ALIGN=CENTER>8</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
<P ALIGN=CENTER>9</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
<P ALIGN=CENTER>9</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="9" SDNUM="3081;">
<P ALIGN=CENTER>9</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="10" SDNUM="3081;">
<P ALIGN=CENTER>10</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="10" SDNUM="3081;">
<P ALIGN=CENTER>10</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
<P ALIGN=CENTER>11</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>Foreground NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
<P ALIGN=CENTER>11</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="11" SDNUM="3081;">
<P ALIGN=CENTER>11</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="12" SDNUM="3081;">
<P ALIGN=CENTER>12</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="12" SDNUM="3081;">
<P ALIGN=CENTER>12</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="13" SDNUM="3081;">
<P ALIGN=CENTER>13</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="14" SDNUM="3081;">
<P ALIGN=CENTER>14</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>HIGH_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>IDLE_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>BELOW_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="15" SDNUM="3081;">
<P ALIGN=CENTER>15</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>ABOVE_NORMAL_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="16" SDNUM="3081;">
<P ALIGN=CENTER>16</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_IDLE</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="17" SDNUM="3081;">
<P ALIGN=CENTER>17</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-7" SDNUM="3081;">
<P ALIGN=LEFT>-7</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="18" SDNUM="3081;">
<P ALIGN=CENTER>18</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-6" SDNUM="3081;">
<P ALIGN=LEFT>-6</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="19" SDNUM="3081;">
<P ALIGN=CENTER>19</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-5" SDNUM="3081;">
<P ALIGN=LEFT>-5</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="20" SDNUM="3081;">
<P ALIGN=CENTER>20</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-4" SDNUM="3081;">
<P ALIGN=LEFT>-4</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="21" SDNUM="3081;">
<P ALIGN=CENTER>21</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="-3" SDNUM="3081;">
<P ALIGN=LEFT>-3</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="22" SDNUM="3081;">
<P ALIGN=CENTER>22</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_LOWEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="23" SDNUM="3081;">
<P ALIGN=CENTER>23</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_BELOW_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="24" SDNUM="3081;">
<P ALIGN=CENTER>24</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="25" SDNUM="3081;">
<P ALIGN=CENTER>25</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_ABOVE_NORMAL</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="26" SDNUM="3081;">
<P ALIGN=CENTER>26</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_HIGHEST</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="27" SDNUM="3081;">
<P ALIGN=CENTER>27</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="3" SDNUM="3081;">
<P ALIGN=LEFT>3</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="28" SDNUM="3081;">
<P ALIGN=CENTER>28</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="4" SDNUM="3081;">
<P ALIGN=LEFT>4</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="29" SDNUM="3081;">
<P ALIGN=CENTER>29</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="5" SDNUM="3081;">
<P ALIGN=LEFT>5</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="30" SDNUM="3081;">
<P ALIGN=CENTER>30</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=BOTTOM SDVAL="6" SDNUM="3081;">
<P ALIGN=LEFT>6</P>
</TD>
</TR>
<TR>
<TD WIDTH=50 VALIGN=BOTTOM SDVAL="31" SDNUM="3081;">
<P ALIGN=CENTER>31</P>
</TD>
<TD WIDTH=356 VALIGN=TOP>
<P ALIGN=LEFT>REALTIME_PRIORITY_CLASS</P>
</TD>
<TD WIDTH=336 VALIGN=TOP>
<P ALIGN=LEFT>THREAD_PRIORITY_TIME_CRITICAL</P>
</TD>
</TR>
</TBODY>
</TABLE>
</DL>
</DL>
<P STYLE="margin-left: 2cm">Windows NT: Values -7, -6, -5, -4, -3, 3,
4, 5, and 6 are not supported.</P>
<P STYLE="margin-left: 2cm">As you can see, the real priority levels
available to any individual Win32 thread are non-contiguous.</P>
<P STYLE="margin-left: 2cm">An application using Pthreads-w32 should
not make assumptions about the numbers used to represent thread
priority levels, except that they are monotonic between the values
returned by sched_get_priority_min() and sched_get_priority_max().
E.g. Windows 95, 98, NT, 2000, XP make available a non-contiguous
range of numbers between -15 and 15, while at least one version of
WinCE (3.0) defines the minimum priority (THREAD_PRIORITY_LOWEST) as
5, and the maximum priority (THREAD_PRIORITY_HIGHEST) as 1.</P>
<P STYLE="margin-left: 2cm">Internally, pthreads-win32 maps any
priority levels between THREAD_PRIORITY_IDLE and
THREAD_PRIORITY_LOWEST to THREAD_PRIORITY_LOWEST, or between
THREAD_PRIORITY_TIME_CRITICAL and THREAD_PRIORITY_HIGHEST to
THREAD_PRIORITY_HIGHEST. Currently, this also applies to
REALTIME_PRIORITY_CLASS even if levels -7, -6, -5, -4, -3, 3, 4, 5,
and 6 are supported.</P>
<P STYLE="margin-left: 2cm">If it wishes, a Win32 application using
pthreads-w32 can use the Win32 defined priority macros
THREAD_PRIORITY_IDLE through THREAD_PRIORITY_TIME_CRITICAL.</P>
<H2><A HREF="#toc3" NAME="sect3">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc4" NAME="sect4">See also</A></H2>
<P><BR><BR>
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Author</A>
</P>
<LI><P><A HREF="#sect4" NAME="toc4">See also</A>
</P>
</UL>
</BODY>
</HTML>

158
3rdparty/pthreads4w/manual/index.html vendored
View File

@ -1,158 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE></TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2 (Linux)">
<META NAME="CREATED" CONTENT="20050504;17350500">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20110326;18352700">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<STYLE TYPE="text/css">
<!--
H4.cjk { font-family: "AR PL UMing CN" }
H4.ctl { font-family: "Lohit Devanagari" }
H3.cjk { font-family: "AR PL UMing CN" }
H3.ctl { font-family: "Lohit Devanagari" }
H2.cjk { font-family: "AR PL UMing CN" }
H2.ctl { font-family: "Lohit Devanagari" }
-->
</STYLE>
</HEAD>
<BODY LANG="en-GB" DIR="LTR">
<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
<A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<H3 CLASS="western">Table of Contents</H3>
<P STYLE="margin-left: 0.79in"><A HREF="#sect1" NAME="toc1">POSIX
threads API reference</A><BR><A HREF="#sect2" NAME="toc2">Miscellaneous
POSIX thread safe routines provided by Pthreads-w32</A><BR><A HREF="#sect3" NAME="toc3">Non-portable
Pthreads-w32 routines</A><BR><A HREF="#sect4" NAME="toc4">Other</A></P>
<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">POSIX threads API
reference</A></H2>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_getinheritsched</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_getschedparam</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_getschedpolicy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_getscope</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_getstackaddr</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_setstacksize.html"><B>pthread_attr_getstacksize</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_setdetachstate</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_setinheritsched</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_setschedparam</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_setschedpolicy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_init.html"><B>pthread_attr_setscope</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_setstackaddr</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_attr_setstacksize.html"><B>pthread_attr_setstacksize</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_getpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_setpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrier_init.html"><B>pthread_barrier_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cancel.html"><B>pthread_cancel</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_pop</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_condattr_init.html"><B>pthread_condattr_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_condattr_setpshared.html"><B>pthread_condattr_getpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_condattr_init.html"><B>pthread_condattr_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_condattr_setpshared.html"><B>pthread_condattr_setpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_broadcast</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_signal</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_timedwait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cond_init.html"><B>pthread_cond_wait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_create.html"><B>pthread_create</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_detach.html"><B>pthread_detach</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_equal.html"><B>pthread_equal</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_exit.html"><B>pthread_exit</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_setconcurrency.html"><B>pthread_getconcurrency</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_setschedparam.html"><B>pthread_getschedparam</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_getunique_np.html"><B>pthread_getunique_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_key_create.html"><B>pthread_getspecific</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_join.html"><B>pthread_join</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_key_create.html"><B>pthread_key_create</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_key_create.html"><B>pthread_key_delete</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_kill.html"><B>pthread_kill</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_getkind_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_setpshared.html"><B>pthread_mutexattr_getpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_getrobust</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_gettype</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_setkind_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_setpshared.html"><B>pthread_mutexattr_setpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_setrobust</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_settype</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_consistent</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_lock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_timedlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_trylock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_mutex_init.html"><B>pthread_mutex_unlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_once.html"><B>pthread_once</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_getpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_setpshared</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_self.html"><B>pthread_self</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cancel.html"><B>pthread_setcancelstate</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_setconcurrency.html"><B>pthread_setconcurrency</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_key_create.html"><B>pthread_setspecific</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_kill.html"><B>pthread_sigmask</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_spin_init.html"><B>pthread_spin_init</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_cancel.html"><B>pthread_testcancel</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sched_get_priority_max.html"><B>sched_get_priority_max</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sched_get_priority_max.html"><B>sched_get_priority_min</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sched_yield.html"><B>sched_yield</B></A></P>
<P STYLE="margin-left: 0.79in"><B>sem_close</B></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_destroy</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_getvalue</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_init</B></A></P>
<P STYLE="margin-left: 0.79in"><B>sem_open</B></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_post</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_post_multiple</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_timedwait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_trywait</B></A></P>
<P STYLE="margin-left: 0.79in"><B>sem_unlink</B></P>
<P STYLE="margin-left: 0.79in"><A HREF="sem_init.html"><B>sem_wait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_kill.html"><B>sigwait</B></A></P>
<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Non-portable
Pthreads-w32 routines</A></H2>
<P STYLE="margin-left: 0.79in"><A HREF="pthreadCancelableWait.html"><B>pthreadCancelableTimedWait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthreadCancelableWait.html"><B>pthreadCancelableWait</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_delay_np.html"><B>pthread_delay_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_getw32threadhandle_np.html"><B>pthread_getw32threadhandle_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_num_processors_np.html"><B>pthread_num_processors_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_win32_test_features_np.html"><B>pthread_win32_test_features_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_timechange_handler_np.html"><B>pthread_timechange_handler_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_process_attach_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_process_detach_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_thread_attach_np</B></A></P>
<P STYLE="margin-left: 0.79in"><A HREF="pthread_win32_attach_detach_np.html"><B>pthread_win32_thread_detach_np</B></A></P>
<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Other</A></H2>
<P STYLE="margin-left: 0.79in"><A HREF="PortabilityIssues.html"><B>Portability
issues</B></A></P>
</BODY>
</HTML>

86
3rdparty/pthreads4w/manual/pthreadCancelableWait.html vendored
View File

@ -1,86 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREADCANCELLABLEWAIT manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;23242300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthreadCancelableTimedWait,
pthreadCancelableWait – provide cancellation hooks for user Win32
routines</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthreadCancelableTimedWait (HANDLE </B><I>waitHandle</I><B>,
DWORD </B><I>timeout</I><B>);</B></P>
<P><B>int pthreadCancelableWait (HANDLE </B><I>waitHandle</I><B>);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>These two functions provide hooks into the <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>()
mechanism that will allow you to wait on a Windows handle and make it
a cancellation point. Both functions block until either the given
Win32 <B>HANDLE</B> is signalled, or <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>()
has been called. They are implemented using <B>WaitForMultipleObjects</B>
on <I>waitHandle</I> and the manually reset Win32 event handle that
is the target of <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>().
These routines may be called from Win32 native threads but
<A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>() will
require that thread's POSIX thread ID that the thread must retrieve
using <A HREF="pthread_self.html"><B>pthread_self</B></A>().</P>
<P><B>pthreadCancelableTimedWait</B> is the timed version that will
return with the code <B>ETIMEDOUT</B> if the interval <I>timeout</I>
milliseconds elapses before <I>waitHandle</I> is signalled.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>These routines allow routines that block on Win32 HANDLEs to be
cancellable via <A HREF="pthread_cancel.html"><B>pthread_cancel</B></A>().</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P><BR><BR>
</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>The <B>pthreadCancelableTimedWait</B> function returns the
following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm">
The interval <I>timeout</I> milliseconds elapsed before <I>waitHandle</I>
was signalled.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc7" NAME="sect7">See also</A></H2>
<P><A HREF="pthread_cancel.html"><B>pthread_cancel()</B></A>,
<A HREF="pthread_self.html"><B>pthread_self()</B></A></P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4"></A><A HREF="#sect4" NAME="toc4">Return
Value</A><A HREF="#sect4" NAME="toc4"></A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
</P>
<LI><P><A HREF="#sect7" NAME="toc7">See also</A>
</P>
</UL>
</BODY>
</HTML>

280
3rdparty/pthreads4w/manual/pthread_attr_init.html vendored
View File

@ -1,280 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_ATTR_INIT(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;10092900">
<META NAME="CHANGED" CONTENT="20050505;16540200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_attr_init, pthread_attr_destroy,
pthread_attr_setdetachstate, pthread_attr_getdetachstate,
pthread_attr_setschedparam, pthread_attr_getschedparam,
pthread_attr_setschedpolicy, pthread_attr_getschedpolicy,
pthread_attr_setinheritsched, pthread_attr_getinheritsched,
pthread_attr_setscope, pthread_attr_getscope - thread creation
attributes
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_attr_init(pthread_attr_t *</B><I>attr</I><B>);</B>
</P>
<P><B>int pthread_attr_destroy(pthread_attr_t *</B><I>attr</I><B>);</B>
</P>
<P><B>int pthread_attr_setdetachstate(pthread_attr_t *</B><I>attr</I><B>,
int </B><I>detachstate</I><B>);</B>
</P>
<P><B>int pthread_attr_getdetachstate(const pthread_attr_t *</B><I>attr</I><B>,
int *</B><I>detachstate</I><B>);</B>
</P>
<P><B>int pthread_attr_setschedpolicy(pthread_attr_t *</B><I>attr</I><B>,
int </B><I>policy</I><B>);</B>
</P>
<P><B>int pthread_attr_getschedpolicy(const pthread_attr_t *</B><I>attr</I><B>,
int *</B><I>policy</I><B>);</B>
</P>
<P><B>int pthread_attr_setschedparam(pthread_attr_t *</B><I>attr</I><B>,
const struct sched_param *</B><I>param</I><B>);</B>
</P>
<P><B>int pthread_attr_getschedparam(const pthread_attr_t *</B><I>attr</I><B>,
struct sched_param *</B><I>param</I><B>);</B>
</P>
<P><B>int pthread_attr_setinheritsched(pthread_attr_t *</B><I>attr</I><B>,
int </B><I>inherit</I><B>);</B>
</P>
<P><B>int pthread_attr_getinheritsched(const pthread_attr_t *</B><I>attr</I><B>,
int *</B><I>inherit</I><B>);</B>
</P>
<P><B>int pthread_attr_setscope(pthread_attr_t *</B><I>attr</I><B>,
int </B><I>scope</I><B>);</B>
</P>
<P><B>int pthread_attr_getscope(const pthread_attr_t *</B><I>attr</I><B>,
int *</B><I>scope</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Setting attributes for threads is achieved by filling a thread
attribute object <I>attr</I> of type <B>pthread_attr_t</B>, then
passing it as second argument to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
. Passing <B>NULL</B> is equivalent to passing a thread attribute
object with all attributes set to their default values.
</P>
<P><B>pthread_attr_init</B> initializes the thread attribute object
<I>attr</I> and fills it with default values for the attributes. (The
default values are listed below for each attribute.)
</P>
<P>Each attribute <I>attrname</I> (see below for a list of all
attributes) can be individually set using the function
<B>pthread_attr_set</B><I>attrname</I> and retrieved using the
function <B>pthread_attr_get</B><I>attrname.</I>
</P>
<P><B>pthread_attr_destroy</B> destroys a thread attribute object,
which must not then be reused until it is reinitialized.
</P>
<P>Attribute objects are consulted only when creating a new thread.
The same attribute object can be used for creating several threads.
Modifying an attribute object after a call to <B>pthread_create</B>
does not change the attributes of the thread previously created.
</P>
<P>The following thread attributes are supported:
</P>
<H3><A HREF="#toc3" NAME="sect3">detachstate</A></H3>
<P>Control whether the thread is created in the joinable state (value
<B>PTHREAD_CREATE_JOINABLE</B>) or in the detached state (
<B>PTHREAD_CREATE_DETACHED</B>).
</P>
<P>Default value: <B>PTHREAD_CREATE_JOINABLE</B>.
</P>
<P>In the joinable state, another thread can synchronize on the
thread termination and recover its termination code using
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> . When a
joinable thread terminates, some of the thread resources are kept
allocated, and released only when another thread performs
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> on that
thread.
</P>
<P>In the detached state, the thread's resources are released
immediately when it terminates. <A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
cannot be used to synchronize on the thread termination.
</P>
<P>A thread created in the joinable state can later be put in the
detached thread using <A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A>
.
</P>
<H3><A HREF="#toc4" NAME="sect4">schedpolicy</A></H3>
<P>Select the scheduling policy for the thread: one of <B>SCHED_OTHER</B>
(regular, non-real-time scheduling), <B>SCHED_RR</B> (real-time,
round-robin) or <B>SCHED_FIFO</B> (real-time, first-in first-out).
</P>
<P><B>Pthreads-w32</B> only supports <B>SCHED_OTHER</B> - attempting
to set one of the other policies will return an error ENOTSUP.</P>
<P>Default value: <B>SCHED_OTHER</B>.
</P>
<P><B>Pthreads-w32</B> only supports <B>SCHED_OTHER</B> - attempting
to set one of the other policies will return an error ENOTSUP.</P>
<P>The scheduling policy of a thread can be changed after creation
with <A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
.
</P>
<H3><A HREF="#toc5" NAME="sect5">schedparam</A></H3>
<P>Contain the scheduling parameters (essentially, the scheduling
priority) for the thread.</P>
<P><B>Pthreads-w32</B> supports the priority levels defined by the
Windows system it is running on. Under Windows, thread priorities are
relative to the process priority class, which must be set via the
Windows W32 API.</P>
<P>Default value: priority is 0 (Win32 level <B>THREAD_PRIORITY_NORMAL</B>).
</P>
<P>The scheduling priority of a thread can be changed after creation
with <A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
.
</P>
<H3><A HREF="#toc6" NAME="sect6">inheritsched</A></H3>
<P>Indicate whether the scheduling policy and scheduling parameters
for the newly created thread are determined by the values of the
<I>schedpolicy</I> and <I>schedparam</I> attributes (value
<B>PTHREAD_EXPLICIT_SCHED</B>) or are inherited from the parent
thread (value <B>PTHREAD_INHERIT_SCHED</B>).
</P>
<P>Default value: <B>PTHREAD_EXPLICIT_SCHED</B>.
</P>
<H3><A HREF="#toc7" NAME="sect7">scope</A></H3>
<P>Define the scheduling contention scope for the created thread. The
only value supported in the <B>Pthreads-w32</B> implementation is
<B>PTHREAD_SCOPE_SYSTEM</B>, meaning that the threads contend for CPU
time with all processes running on the machine. The other value
specified by the standard, <B>PTHREAD_SCOPE_PROCESS</B>, means that
scheduling contention occurs only between the threads of the running
process.</P>
<P><B>Pthreads-w32</B> only supports <B>PTHREAD_SCOPE_SYSTEM</B>.</P>
<P>Default value: <B>PTHREAD_SCOPE_SYSTEM</B>.
</P>
<H2><A HREF="#toc8" NAME="sect8">Return Value</A></H2>
<P>All functions return 0 on success and a non-zero error code on
error. On success, the <B>pthread_attr_get</B><I>attrname</I>
functions also store the current value of the attribute <I>attrname</I>
in the location pointed to by their second argument.
</P>
<H2><A HREF="#toc9" NAME="sect9">Errors</A></H2>
<P>The <B>pthread_attr_setdetachstate</B> function returns the
following error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the specified <I>detachstate</I> is not one of
<B>PTHREAD_CREATE_JOINABLE</B> or <B>PTHREAD_CREATE_DETACHED</B>.
</DD></DL>
</DL>
<P>
The <B>pthread_attr_setschedparam</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the priority specified in <I>param</I> is outside the range of
allowed priorities for the scheduling policy currently in <I>attr</I>
(1 to 99 for <B>SCHED_FIFO</B> and <B>SCHED_RR</B>; 0 for
<B>SCHED_OTHER</B>).
</DD></DL>
</DL>
<P>
The <B>pthread_attr_setschedpolicy</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the specified <I>policy</I> is not one of <B>SCHED_OTHER</B>,
<B>SCHED_FIFO</B>, or <B>SCHED_RR</B>.
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOTSUP</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>policy</I> is not <B>SCHED_OTHER</B>, the only value supported
by <B>Pthreads-w32</B>.</DD></DL>
</DL>
<P>
The <B>pthread_attr_setinheritsched</B> function returns the
following error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the specified <I>inherit</I> is not one of <B>PTHREAD_INHERIT_SCHED</B>
or <B>PTHREAD_EXPLICIT_SCHED</B>.
</DD></DL>
</DL>
<P>
The <B>pthread_attr_setscope</B> function returns the following error
codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the specified <I>scope</I> is not one of <B>PTHREAD_SCOPE_SYSTEM</B>
or <B>PTHREAD_SCOPE_PROCESS</B>.
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOTSUP</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the specified <I>scope</I> is <B>PTHREAD_SCOPE_PROCESS</B> (not
supported by <B>Pthreads-w32</B>).
</DD></DL>
</DL>
<H2>
<A HREF="#toc10" NAME="sect10">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc11" NAME="sect11">See Also</A></H2>
<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
<A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
.
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">detachstate</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">schedpolicy</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">schedparam</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">inheritsched</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">scope</A>
</P>
</UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect10" NAME="toc10">Author</A>
</P>
<LI><P><A HREF="#sect11" NAME="toc11">See Also</A>
</P>
</UL>
</BODY>
</HTML>

158
3rdparty/pthreads4w/manual/pthread_attr_setstackaddr.html vendored
View File

@ -1,158 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_ATTR_GETSTACKADDR&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11025500">
<META NAME="CHANGED" CONTENT="20050505;17571400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_attr_getstackaddr, pthread_attr_setstackaddr - get and set
the stackaddr attribute
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_attr_getstackaddr(const pthread_attr_t *restrict</B>
<I>attr</I><B>, void **restrict</B> <I>stackaddr</I><B>); <BR>int
pthread_attr_setstackaddr(pthread_attr_t *</B><I>attr</I><B>, void
*</B><I>stackaddr</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_attr_getstackaddr</B> and <B>pthread_attr_setstackaddr</B>
functions, respectively, shall get and set the thread creation
<I>stackaddr</I> attribute in the <I>attr</I> object.
</P>
<P>The <I>stackaddr</I> attribute specifies the location of storage
to be used for the created thread’s stack. The size of the storage
shall be at least {PTHREAD_STACK_MIN}.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_ATTR_STACKADDR</B> in
pthread.h as -1 to indicate that these routines are implemented but
cannot used to set or get the stack address. These routines always
return the error ENOSYS when called.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, <B>pthread_attr_getstackaddr</B> and
<B>pthread_attr_setstackaddr</B> shall return a value of 0;
otherwise, an error number shall be returned to indicate the error.
</P>
<P>The <B>pthread_attr_getstackaddr</B> function stores the <I>stackaddr</I>
attribute value in <I>stackaddr</I> if successful.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_attr_setstackaddr</B> function always returns the
following error code:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOSYS</B></DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The function is not supported.
</DD></DL>
</DL>
<P>
The <B>pthread_attr_getstackaddr</B> function always returns the
following error code:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOSYS</B></DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The function is not supported.
</DD></DL>
</DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>The specification of the <I>stackaddr</I> attribute presents
several ambiguities that make portable use of these interfaces
impossible. The description of the single address parameter as a
&quot;stack&quot; does not specify a particular relationship between
the address and the &quot;stack&quot; implied by that address. For
example, the address may be taken as the low memory address of a
buffer intended for use as a stack, or it may be taken as the address
to be used as the initial stack pointer register value for the new
thread. These two are not the same except for a machine on which the
stack grows &quot;up&quot; from low memory to high, and on which a
&quot;push&quot; operation first stores the value in memory and then
increments the stack pointer register. Further, on a machine where
the stack grows &quot;down&quot; from high memory to low,
interpretation of the address as the &quot;low memory&quot; address
requires a determination of the intended size of the stack.
IEEE&nbsp;Std&nbsp;1003.1-2001 has introduced the new interfaces
<A HREF="pthread_attr_setstack.html"><B>pthread_attr_setstack</B>(3)</A>
and <A HREF="pthread_attr_getstack.html"><B>pthread_attr_getstack</B>(3)</A>
to resolve these ambiguities.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B>(3)</A>
, <A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B>(3)</A>
, <A HREF="pthread_attr_getstack.html"><B>pthread_attr_getstack</B>(3)</A>
, <A HREF="pthread_attr_getstacksize.html"><B>pthread_attr_getstacksize</B>(3)</A>
, <A HREF="pthread_attr_setstack.html"><B>pthread_attr_setstack</B>(3)</A>
, <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> , the
Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;limits.h&gt;</I>, <I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

127
3rdparty/pthreads4w/manual/pthread_attr_setstacksize.html vendored
View File

@ -1,127 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_ATTR_GETSTACKSIZE&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11224900">
<META NAME="CHANGED" CONTENT="20050505;18003200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_attr_getstacksize, pthread_attr_setstacksize - get and set
the stacksize attribute
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_attr_getstacksize(const pthread_attr_t *restrict</B>
<I>attr</I><B>, size_t *restrict</B> <I>stacksize</I><B>); <BR>int
pthread_attr_setstacksize(pthread_attr_t *</B><I>attr</I><B>, size_t</B>
<I>stacksize</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_attr_getstacksize</B> and <B>pthread_attr_setstacksize</B>
functions, respectively, shall get and set the thread creation
<I>stacksize</I> attribute in the <I>attr</I> object.
</P>
<P>The <I>stacksize</I> attribute shall define the minimum stack size
(in bytes) allocated for the created threads stack.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_ATTR_STACKSIZE</B> in
pthread.h to indicate that these routines are implemented and may be
used to set or get the stack size.</P>
<P>Default value: 0 (in Pthreads-w32 a value of 0 means the stack
will grow as required)</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, <B>pthread_attr_getstacksize</B> and
<B>pthread_attr_setstacksize</B> shall return a value of 0;
otherwise, an error number shall be returned to indicate the error.
</P>
<P>The <B>pthread_attr_getstacksize</B> function stores the <I>stacksize</I>
attribute value in <I>stacksize</I> if successful.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_attr_setstacksize</B> function shall fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value of <I>stacksize</I> is less than {PTHREAD_STACK_MIN} or
exceeds a system-imposed limit.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_attr_init.html"><B>pthread_attr_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_attr_setstackaddr.html"><B>pthread_attr_getstackaddr</B>(3)</A>
<B>,</B> <A HREF="pthread_attr_init.html"><B>pthread_attr_getdetachstate</B>(3)</A>
<B>,</B> <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;limits.h&gt;</I>, <I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

197
3rdparty/pthreads4w/manual/pthread_barrier_init.html vendored
View File

@ -1,197 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_BARRIER_DESTROY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.0 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11372800">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20060408;9450100">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_barrier_destroy, pthread_barrier_init - destroy and
initialize a barrier object (<B>ADVANCED REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_barrier_destroy(pthread_barrier_t *</B><I>barrier</I><B>);
<BR>int pthread_barrier_init(pthread_barrier_t *restrict</B> <I>barrier</I><B>,
const pthread_barrierattr_t *restrict</B> <I>attr</I><B>, unsigned</B>
<I>count</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_barrier_destroy</B> function shall destroy the
barrier referenced by <I>barrier</I> and release any resources used
by the barrier. The effect of subsequent use of the barrier is
undefined until the barrier is reinitialized by another call to
<B>pthread_barrier_init</B> . An implementation may use this function
to set <I>barrier</I> to an invalid value. An error code is returned if <B>pthread_barrier_destroy</B> is called when any thread is
blocked on the barrier, or if this function is called with an
uninitialized barrier.
</P>
<P>The <B>pthread_barrier_init</B> function shall allocate any
resources required to use the barrier referenced by <I>barrier</I>
and shall initialize the barrier with attributes referenced by <I>attr</I>.
If <I>attr</I> is NULL, the default barrier attributes shall be used;
the effect is the same as passing the address of a default barrier
attributes object. The results are undefined if <B>pthread_barrier_init</B>
is called when any thread is blocked on the barrier (that is, has not
returned from the <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
call). The results are undefined if a barrier is used without first
being initialized. The results are undefined if <B>pthread_barrier_init</B>
is called specifying an already initialized barrier.
</P>
<P>The <I>count</I> argument specifies the number of threads that
must call <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
before any of them successfully return from the call. The value
specified by <I>count</I> must be greater than zero.
</P>
<P>If the <B>pthread_barrier_init</B> function fails, the barrier
shall not be initialized and the contents of <I>barrier</I> are
undefined.
</P>
<P>Only the object referenced by <I>barrier</I> may be used for
performing synchronization. The result of referring to copies of that
object in calls to <B>pthread_barrier_destroy</B> <B>or</B>
<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
is undefined.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, these functions shall return zero;
otherwise, an error number shall be returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_barrier_destroy</B> function may fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD>
The implementation has detected an attempt to destroy a barrier
while it is in use (for example, while being used in a
<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
call) by another thread.
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>barrier</I> is invalid.
</DD></DL>
<P>
The <B>pthread_barrier_init</B> function shall fail if:
</P>
<DL>
<DT><B>EAGAIN</B>
</DT><DD>
The system lacks the necessary resources to initialize another
barrier.
</DD><DT>
<B>EINVAL</B>
</DT><DD>
The value specified by <I>count</I> is equal to zero.
</DD><DT>
<B>ENOMEM</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
Insufficient memory exists to initialize the barrier.
</DD></DL>
<P>
The <B>pthread_barrier_init</B> function may fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD>
The implementation has detected an attempt to reinitialize a barrier
while it is in use (for example, while being used in a
<A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
call) by another thread.
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>The <B>pthread_barrier_destroy</B> and <B>pthread_barrier_init</B>
functions are part of the Barriers option and need not be provided on
all implementations.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_BARRIERS</B> to indicate
that these routines are implemented and may be used.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc11" NAME="sect11">Known Bugs</A></H2>
<DL>
<DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">In
<B><SPAN LANG="en-GB"><SPAN LANG="en-GB">pthreads-win32</SPAN></SPAN></B>,
the behaviour of threads which enter <A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
while the barrier is being destroyed is undefined.
</DD></DL>
<H2>
<A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_barrier_wait.html"><B>pthread_barrier_wait</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect11" NAME="toc11">Known
Bugs</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

161
3rdparty/pthreads4w/manual/pthread_barrier_wait.html vendored
View File

@ -1,161 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_BARRIER_WAIT&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.0 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11484200">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20060408;9504600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_barrier_wait - synchronize at a barrier (<B>ADVANCED
REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_barrier_wait(pthread_barrier_t *</B><I>barrier</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_barrier_wait</B> function shall synchronize
participating threads at the barrier referenced by <I>barrier</I>.
The calling thread shall block until the required number of threads
have called <B>pthread_barrier_wait</B> specifying the barrier.
</P>
<P>When the required number of threads have called
<B>pthread_barrier_wait</B> specifying the barrier, the constant
<B>PTHREAD_BARRIER_SERIAL_THREAD</B> shall be returned to one
unspecified thread and zero shall be returned to each of the
remaining threads. At this point, the barrier shall be reset to the
state it had as a result of the most recent <A HREF="pthread_barrier_init.html"><B>pthread_barrier_init</B>(3)</A>
function that referenced it.
</P>
<P>The constant <B>PTHREAD_BARRIER_SERIAL_THREAD</B> is defined in
<I>&lt;pthread.h&gt;</I> and its value shall be distinct from any
other value returned by <B>pthread_barrier_wait</B> .
</P>
<P>The results are undefined if this function is called with an
uninitialized barrier.
</P>
<P>If a signal is delivered to a thread blocked on a barrier, upon
return from the signal handler the thread shall resume waiting at the
barrier if the barrier wait has not completed (that is, if the
required number of threads have not arrived at the barrier during the
execution of the signal handler); otherwise, the thread shall
continue as normal from the completed barrier wait. Until the thread
in the signal handler returns from it, it is unspecified whether
other threads may proceed past the barrier once they have all reached
it.
</P>
<P>A thread that has blocked on a barrier shall not prevent any
unblocked thread that is eligible to use the same processing
resources from eventually making forward progress in its execution.
Eligibility for processing resources shall be determined by the
scheduling policy.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, the <B>pthread_barrier_wait</B>
function shall return <B>PTHREAD_BARRIER_SERIAL_THREAD</B> for a
single (arbitrary) thread synchronized at the barrier and zero for
each of the other threads. Otherwise, an error number shall be
returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_barrier_wait</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>barrier</I> does not refer to an
initialized barrier object.
</DD></DL>
<P>
This function shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using this function may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<P>The <B>pthread_barrier_wait</B> function is part of the Barriers
option and need not be provided on all implementations.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_BARRIERS</B> to indicate
that this routine is implemented and may be used.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc11" NAME="sect11">Known Bugs</A></H2>
<DL>
None.</DL>
<H2>
<A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B>(3)</A>,
<A HREF="pthread_barrier_init.html"><B>pthread_barrier_init(3)</B></A>,
the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect11" NAME="toc11">Known
Bugs</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

142
3rdparty/pthreads4w/manual/pthread_barrierattr_init.html vendored
View File

@ -1,142 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_BARRIERATTR_DESTROY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11502600">
<META NAME="CHANGED" CONTENT="20050505;18032300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_barrierattr_destroy, pthread_barrierattr_init - destroy
and initialize the barrier attributes object (<B>ADVANCED REALTIME
THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P>i<B>nt pthread_barrierattr_destroy(pthread_barrierattr_t *</B><I>attr</I><B>);
<BR>int pthread_barrierattr_init(pthread_barrierattr_t *</B><I>attr</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_barrierattr_destroy</B> function shall destroy a
barrier attributes object. A destroyed <I>attr</I> attributes object
can be reinitialized using <B>pthread_barrierattr_init</B> ; the
results of otherwise referencing the object after it has been
destroyed are undefined. An implementation may cause
<B>pthread_barrierattr_destroy</B> to set the object referenced by
<I>attr</I> to an invalid value.
</P>
<P>The <B>pthread_barrierattr_init</B> function shall initialize a
barrier attributes object <I>attr</I> with the default value for all
of the attributes defined by the implementation.
</P>
<P>Results are undefined if <B>pthread_barrierattr_init</B> is called
specifying an already initialized <I>attr</I> attributes object.
</P>
<P>After a barrier attributes object has been used to initialize one
or more barriers, any function affecting the attributes object
(including destruction) shall not affect any previously initialized
barrier.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_barrierattr_destroy</B> and
<B>pthread_barrierattr_init</B> functions shall return zero;
otherwise, an error number shall be returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_barrierattr_destroy</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
The <B>pthread_barrierattr_init</B> function shall fail if:
</P>
<DL>
<DT><B>ENOMEM</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
Insufficient memory exists to initialize the barrier attributes
object.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>The <B>pthread_barrierattr_destroy</B> and
<B>pthread_barrierattr_init</B> functions are part of the Barriers
option and need not be provided on all implementations.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_BARRIERS</B> to indicate
that these routines are implemented and may be used.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_getpshared</B>(3)</A>
<B>,</B> <A HREF="pthread_barrierattr_setpshared.html"><B>pthread_barrierattr_setpshared</B>(3)</A>
, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>.
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

159
3rdparty/pthreads4w/manual/pthread_barrierattr_setpshared.html vendored
View File

@ -1,159 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_BARRIERATTR_GETPSHARED&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;11552100">
<META NAME="CHANGED" CONTENT="20050505;18080400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_barrierattr_getpshared, pthread_barrierattr_setpshared -
get and set the process-shared attribute of the barrier attributes
object (<B>ADVANCED REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_barrierattr_getpshared(const pthread_barrierattr_t
* restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
<BR>int pthread_barrierattr_setpshared(pthread_barrierattr_t *</B><I>attr</I><B>,
int</B> <I>pshared</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_barrierattr_getpshared</B> function shall obtain
the value of the <I>process-shared</I> attribute from the attributes
object referenced by <I>attr</I>. The <B>pthread_barrierattr_setpshared</B>
function shall set the <I>process-shared</I> attribute in an
initialized attributes object referenced by <I>attr</I>.
</P>
<P>The <I>process-shared</I> attribute is set to
PTHREAD_PROCESS_SHARED to permit a barrier to be operated upon by any
thread that has access to the memory where the barrier is allocated.
If the <I>process-shared</I> attribute is PTHREAD_PROCESS_PRIVATE,
the barrier shall only be operated upon by threads created within the
same process as the thread that initialized the barrier; if threads
of different processes attempt to operate on such a barrier, the
behavior is undefined. The default value of the attribute shall be
PTHREAD_PROCESS_PRIVATE. Both constants PTHREAD_PROCESS_SHARED and
PTHREAD_PROCESS_PRIVATE are defined in <I>&lt;pthread.h&gt;</I>.
</P>
<P><B>Pthreads-w32</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines are implemented but
that the process shared attribute is not supported.</P>
<P>Additional attributes, their default values, and the names of the
associated functions to get and set those attribute values are
implementation-defined.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_barrierattr_getpshared</B> function
shall return zero and store the value of the <I>process-shared</I>
attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
parameter. Otherwise, an error number shall be returned to indicate
the error.
</P>
<P>If successful, the <B>pthread_barrierattr_setpshared</B> function
shall return zero; otherwise, an error number shall be returned to
indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>These functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD><DT>
The <B>pthread_barrierattr_setpshared</B> function may fail if:
</DT><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the <I>process-shared</I> attribute is
not one of the legal values <B>PTHREAD_PROCESS_SHARED</B> or
<B>PTHREAD_PROCESS_PRIVATE</B>.
</DD><DT>
<B>ENOSYS</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> was <B>PTHREAD_PROCESS_SHARED</B>
(Pthreads-w32).</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>The <B>pthread_barrierattr_getpshared</B> and
<B>pthread_barrierattr_setpshared</B> functions are part of the
Barriers option and need not be provided on all implementations.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_BARRIERS</B> and
<B>_POSIX_THREAD_PROCESS_SHARED</B> in pthread.h as -1 to indicate
that these routines are implemented and may be used, but do not
support the process shared option.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_barrier_init.html"><B>pthread_barrier_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_barrierattr_init.html"><B>pthread_barrierattr_init</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

205
3rdparty/pthreads4w/manual/pthread_cancel.html vendored
View File

@ -1,205 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CANCEL(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;12090500">
<META NAME="CHANGED" CONTENT="20050505;18220000">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
pthread_testcancel - thread cancellation
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B>
</P>
<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
*</B><I>oldstate</I><B>);</B>
</P>
<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
*</B><I>oldtype</I><B>);</B>
</P>
<P><B>void pthread_testcancel(void);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Cancellation is the mechanism by which a thread can terminate the
execution of another thread. More precisely, a thread can send a
cancellation request to another thread. Depending on its settings,
the target thread can then either ignore the request, honor it
immediately, or defer it until it reaches a cancellation point.
</P>
<P>When a thread eventually honors a cancellation request, it
performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
at that point: all cleanup handlers are executed in reverse order,
destructor functions for thread-specific data are called, and finally
the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
information.
</P>
<P><B>pthread_cancel</B> sends a cancellation request to the thread
denoted by the <I>thread</I> argument.
</P>
<P><B>pthread_setcancelstate</B> changes the cancellation state for
the calling thread -- that is, whether cancellation requests are
ignored or not. The <I>state</I> argument is the new cancellation
state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
previous cancellation state is stored in the location pointed to by
<I>oldstate</I>, and can thus be restored later by another call to
<B>pthread_setcancelstate</B>.
</P>
<P><B>pthread_setcanceltype</B> changes the type of responses to
cancellation requests for the calling thread: asynchronous
(immediate) or deferred. The <I>type</I> argument is the new
cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
cancel the calling thread as soon as the cancellation request is
received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
request pending until the next cancellation point. If <I>oldtype</I>
is not <B>NULL</B>, the previous cancellation state is stored in the
location pointed to by <I>oldtype</I>, and can thus be restored later
by another call to <B>pthread_setcanceltype</B>.
</P>
<P><B>Pthreads-w32</B> provides two levels of support for
<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
requires an additional DLL and driver be installed on the Windows
system (see the See Also section below) that allows blocked threads
to be cancelled immediately. Partial support means that the target
thread will not cancel until it resumes execution naturally. Partial
support is provided if either the DLL or the driver are not
automatically detected by the pthreads-w32 library at run-time.</P>
<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
with cancellation enabled and deferred. That is, the initial
cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
type is <B>PTHREAD_CANCEL_DEFERRED</B>.
</P>
<P>Cancellation points are those points in the program execution
where a test for pending cancellation requests is performed and
cancellation is executed if positive. The following POSIX threads
functions are cancellation points:
</P>
<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
<BR><A HREF="pthread_cond_init.html"><B>pthread_cond_wait</B>(3)</A>
<BR><A HREF="pthread_cond_init.html"><B>pthread_cond_timedwait</B>(3)</A>
<BR><A HREF=""><B>pthread_testcancel</B>(3)</A> <BR><A HREF="sem_init.html"><B>sem_wait</B>(3)</A>
<BR><A HREF="sem_init.html"><B>sem_timedwait</B>(3)</A> <BR><A HREF="pthread_kill.html"><B>sigwait</B>(3)</A></P>
<P><B>Pthreads-w32</B> provides two functions to enable additional
cancellation points to be created in user functions that block on
Win32 HANDLEs:</P>
<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
<P>All other POSIX threads functions are guaranteed not to be
cancellation points. That is, they never perform cancellation in
deferred cancellation mode.
</P>
<P><B>pthread_testcancel</B> does nothing except testing for pending
cancellation and executing it. Its purpose is to introduce explicit
checks for cancellation in long sequences of code that do not call
cancellation point functions otherwise.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
code on error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P><B>pthread_cancel</B> returns the following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
no thread could be found corresponding to that specified by the
<I>thread</I> ID.
</DD></DL>
</DL>
<P>
<B>pthread_setcancelstate</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>state</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B>
</BLOCKQUOTE>
<P><B>pthread_setcanceltype</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>type</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
</BLOCKQUOTE>
<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
, Pthreads-w32 package README file 'Prerequisites' section.
</P>
<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
<P>POSIX specifies that a number of system calls (basically, all
system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
, etc.) and library functions that may call these system calls (e.g.
<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
points. <B>Pthreads-win32</B> is not integrated enough with the C
library to implement this, and thus none of the C library functions
is a cancellation point.
</P>
<P>A workaround for these calls is to temporarily switch to
asynchronous cancellation (assuming full asynchronous cancellation
support is installed). So, checking for cancellation during a <B>read</B>
system call, for instance, can be achieved as follows:
</P>
<BLOCKQUOTE><BR><BR>
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
read(fd, buffer, length);
pthread_setcanceltype(oldCancelType, NULL);</PRE>
<HR>
<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

140
3rdparty/pthreads4w/manual/pthread_cleanup_push.html vendored
View File

@ -1,140 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CLEANUP(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;20152200">
<META NAME="CHANGED" CONTENT="20050505;18252600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_cleanup_push, pthread_cleanup_pop - install and remove
cleanup handlers
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>void pthread_cleanup_push(void (*</B><I>routine</I><B>) (void
*), void *</B><I>arg</I><B>);</B>
</P>
<P><B>void pthread_cleanup_pop(int </B><I>execute</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Cleanup handlers are functions that get called when a thread
terminates, either by calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
or because of cancellation. Cleanup handlers are installed and
removed following a stack-like discipline.
</P>
<P>The purpose of cleanup handlers is to free the resources that a
thread may hold at the time it terminates. In particular, if a thread
exits or is cancelled while it owns a locked mutex, the mutex will
remain locked forever and prevent other threads from executing
normally. The best way to avoid this is, just before locking the
mutex, to install a cleanup handler whose effect is to unlock the
mutex. Cleanup handlers can be used similarly to free blocks
allocated with <A HREF="malloc.html"><B>malloc</B>(3)</A> or close
file descriptors on thread termination.
</P>
<P><B>pthread_cleanup_push</B> installs the <I>routine</I> function
with argument <I>arg</I> as a cleanup handler. From this point on to
the matching <B>pthread_cleanup_pop</B>, the function <I>routine</I>
will be called with arguments <I>arg</I> when the thread terminates,
either through <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
or by cancellation. If several cleanup handlers are active at that
point, they are called in LIFO order: the most recently installed
handler is called first.
</P>
<P><B>pthread_cleanup_pop</B> removes the most recently installed
cleanup handler. If the <I>execute</I> argument is not 0, it also
executes the handler, by calling the <I>routine</I> function with
arguments <I>arg</I>. If the <I>execute</I> argument is 0, the
handler is only removed but not executed.
</P>
<P>Matching pairs of <B>pthread_cleanup_push</B> and
<B>pthread_cleanup_pop</B> must occur in the same function, at the
same level of block nesting. Actually, <B>pthread_cleanup_push</B>
and <B>pthread_cleanup_pop</B> are macros, and the expansion of
<B>pthread_cleanup_push</B> introduces an open brace <B>{</B> with
the matching closing brace <B>}</B> being introduced by the expansion
of the matching <B>pthread_cleanup_pop</B>.
</P>
<H2 STYLE="margin-top: 0cm"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">None.
</BLOCKQUOTE>
<H2 STYLE="margin-top: 0cm"><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">None.
</BLOCKQUOTE>
<H2 STYLE="margin-top: 0cm"><A HREF="#toc5" NAME="sect5">Author</A></H2>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Xavier Leroy
&lt;Xavier.Leroy@inria.fr&gt;
</BLOCKQUOTE>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Modified by
Ross Johnson for use with Pthreads-w32.</BLOCKQUOTE>
<H2 STYLE="margin-top: 0cm"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
, <A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> ,
<A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B>(3)</A> .
</BLOCKQUOTE>
<H2 STYLE="margin-top: 0cm"><A HREF="#toc7" NAME="sect7">Example</A></H2>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">Here is how
to lock a mutex <I>mut</I> in such a way that it will be unlocked if
the thread is canceled while <I>mut</I> is locked:
</BLOCKQUOTE>
<PRE>pthread_cleanup_push(pthread_mutex_unlock, (void *) &amp;mut);
pthread_mutex_lock(&amp;mut);
/* do some work */
pthread_mutex_unlock(&amp;mut);
pthread_cleanup_pop(0);</PRE><BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">
Equivalently, the last two lines can be replaced by
</BLOCKQUOTE>
<PRE STYLE="margin-bottom: 0.5cm">pthread_cleanup_pop(1);</PRE><BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">
Notice that the code above is safe only in deferred cancellation mode
(see <A HREF="pthread_cancel.html"><B>pthread_setcanceltype</B>(3)</A>
). In asynchronous cancellation mode, a cancellation can occur
between <B>pthread_cleanup_push</B> and <B>pthread_mutex_lock</B>, or
between <B>pthread_mutex_unlock</B> and <B>pthread_cleanup_pop</B>,
resulting in both cases in the thread trying to unlock a mutex not
locked by the current thread. This is the main reason why
asynchronous cancellation is difficult to use.
</BLOCKQUOTE>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm">If the code
above must also work in asynchronous cancellation mode, then it must
switch to deferred mode for locking and unlocking the mutex:
</BLOCKQUOTE>
<PRE>pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &amp;oldtype);
pthread_cleanup_push(pthread_mutex_unlock, (void *) &amp;mut);
pthread_mutex_lock(&amp;mut);
/* do some work */
pthread_cleanup_pop(1);
pthread_setcanceltype(oldtype, NULL);</PRE>
<HR>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
<B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm"><A HREF="#sect7" NAME="toc7">Example</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

313
3rdparty/pthreads4w/manual/pthread_cond_init.html vendored
View File

@ -1,313 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_COND(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;16454400">
<META NAME="CHANGED" CONTENT="20050505;19004700">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_cond_init, pthread_cond_destroy, pthread_cond_signal,
pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait -
operations on conditions
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>pthread_cond_t </B><I>cond</I> <B>= PTHREAD_COND_INITIALIZER;</B>
</P>
<P><B>int pthread_cond_init(pthread_cond_t *</B><I>cond</I><B>,
pthread_condattr_t *</B><I>cond_attr</I><B>);</B>
</P>
<P><B>int pthread_cond_signal(pthread_cond_t *</B><I>cond</I><B>);</B>
</P>
<P><B>int pthread_cond_broadcast(pthread_cond_t *</B><I>cond</I><B>);</B>
</P>
<P><B>int pthread_cond_wait(pthread_cond_t *</B><I>cond</I><B>,
pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<P><B>int pthread_cond_timedwait(pthread_cond_t *</B><I>cond</I><B>,
pthread_mutex_t *</B><I>mutex</I><B>, const struct timespec
*</B><I>abstime</I><B>);</B>
</P>
<P><B>int pthread_cond_destroy(pthread_cond_t *</B><I>cond</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>A condition (short for ‘‘condition variable’’) is a
synchronization device that allows threads to suspend execution and
relinquish the processors until some predicate on shared data is
satisfied. The basic operations on conditions are: signal the
condition (when the predicate becomes true), and wait for the
condition, suspending the thread execution until another thread
signals the condition.
</P>
<P>A condition variable must always be associated with a mutex, to
avoid the race condition where a thread prepares to wait on a
condition variable and another thread signals the condition just
before the first thread actually waits on it.
</P>
<P><B>pthread_cond_init</B> initializes the condition variable <I>cond</I>,
using the condition attributes specified in <I>cond_attr</I>, or
default attributes if <I>cond_attr</I> is <B>NULL</B>.
</P>
<P>Variables of type <B>pthread_cond_t</B> can also be initialized
statically, using the constant <B>PTHREAD_COND_INITIALIZER</B>. In
the <B>Pthreads-w32</B> implementation, an application should still
call <B>pthread_cond_destroy</B> at some point to ensure that any
resources consumed by the condition variable are released.</P>
<P><B>pthread_cond_signal</B> restarts one of the threads that are
waiting on the condition variable <I>cond</I>. If no threads are
waiting on <I>cond</I>, nothing happens. If several threads are
waiting on <I>cond</I>, exactly one is restarted, but it is not
specified which.
</P>
<P><B>pthread_cond_broadcast</B> restarts all the threads that are
waiting on the condition variable <I>cond</I>. Nothing happens if no
threads are waiting on <I>cond</I>.
</P>
<P><B>pthread_cond_wait</B> atomically unlocks the <I>mutex</I> (as
per <B>pthread_unlock_mutex</B>) and waits for the condition variable
<I>cond</I> to be signalled. The thread execution is suspended and
does not consume any CPU time until the condition variable is
signalled. The <I>mutex</I> must be locked by the calling thread on
entrance to <B>pthread_cond_wait</B>. Before returning to the calling
thread, <B>pthread_cond_wait</B> re-acquires <I>mutex</I> (as per
<B>pthread_lock_mutex</B>).
</P>
<P>Unlocking the mutex and suspending on the condition variable is
done atomically. Thus, if all threads always acquire the mutex before
signalling the condition, this guarantees that the condition cannot
be signalled (and thus ignored) between the time a thread locks the
mutex and the time it waits on the condition variable.
</P>
<P><B>pthread_cond_timedwait</B> atomically unlocks <I>mutex</I> and
waits on <I>cond</I>, as <B>pthread_cond_wait</B> does, but it also
bounds the duration of the wait. If <I>cond</I> has not been
signalled within the amount of time specified by <I>abstime</I>, the
mutex <I>mutex</I> is re-acquired and <B>pthread_cond_timedwait</B>
returns the error <B>ETIMEDOUT</B>. The <I>abstime</I> parameter
specifies an absolute time, with the same origin as <A HREF="time.html"><B>time</B>(2)</A>
and <A HREF="gettimeofday.html"><B>gettimeofday</B>(2)</A>.
</P>
<P><B>pthread_cond_destroy</B> destroys a condition variable, freeing
the resources it might hold. No threads must be waiting on the
condition variable on entrance to <B>pthread_cond_destroy</B>.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P><B>pthread_cond_wait</B> and <B>pthread_cond_timedwait</B> are
cancellation points. If a thread is cancelled while suspended in one
of these functions, the thread immediately resumes execution, then
locks again the <I>mutex</I> argument to <B>pthread_cond_wait</B> and
<B>pthread_cond_timedwait</B>, and finally executes the cancellation.
Consequently, cleanup handlers are assured that <I>mutex</I> is
locked when they are called.
</P>
<H2><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
<P>The condition functions are not async-signal safe, and should not
be called from a signal handler. In particular, calling
<B>pthread_cond_signal</B> or <B>pthread_cond_broadcast</B> from a
signal handler may deadlock the calling thread.
</P>
<H2><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
<P>All condition variable functions return 0 on success and a
non-zero error code on error.
</P>
<H2><A HREF="#toc6" NAME="sect6">Errors</A></H2>
<P><B>pthread_cond_init</B>, <B>pthread_cond_signal</B>,
<B>pthread_cond_broadcast</B>, and <B>pthread_cond_wait</B> never
return an error code.
</P>
<P>The <B>pthread_cond_init</B> function returns the following error
codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>cond</I> argument is invalid.
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOMEM</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 4cm">
There was not enough memory to allocate the condition variable.
</BLOCKQUOTE>
<P>The <B>pthread_cond_signal</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>cond</I> argument is invalid.
</DD></DL>
</DL>
<P>
The <B>pthread_cond_broadcast</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>cond</I> argument is invalid.
</DD></DL>
</DL>
<P>
The <B>pthread_cond_wait</B> function returns the following error
codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>cond</I> argument is invalid.
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOMEM</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 4cm">
There was not enough memory to allocate the statically initialised
condition variable. Statically initialised condition variables are
dynamically allocated by the first thread to wait on them.</BLOCKQUOTE>
<P>The <B>pthread_cond_timedwait</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm">
The <I>cond</I> argument is invalid.
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The condition variable was not signalled before the timeout
specified by <I>abstime</I>
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOMEM</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 4cm">
There was not enough memory to allocate the statically initialised
condition variable. Statically initialised condition variables are
dynamically allocated by the first thread to wait on them.
</BLOCKQUOTE>
<P>The <B>pthread_cond_destroy</B> function returns the following
error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm; margin-right: 1cm">
The <I>cond</I> argument is invalid.
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EBUSY</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
Some threads are currently waiting on <I>cond</I>.
</DD></DL>
</DL>
<H2>
<A HREF="#toc7" NAME="sect7">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc8" NAME="sect8">See Also</A></H2>
<P><A HREF="pthread_condattr_init.html"><B>pthread_condattr_init</B>(3)</A>
, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
, <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
, <A HREF="pthread_cancel.html"><B>pthread_cancel(3)</B></A>.
</P>
<H2><A HREF="#toc9" NAME="sect9">Example</A></H2>
<P>Consider two shared variables <I>x</I> and <I>y</I>, protected by
the mutex <I>mut</I>, and a condition variable <I>cond</I> that is to
be signaled whenever <I>x</I> becomes greater than <I>y</I>.
</P>
<PRE STYLE="margin-left: 1cm; margin-right: 1cm">int x,y;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;</PRE><BLOCKQUOTE>
Waiting until <I>x</I> is greater than <I>y</I> is performed as
follows:
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1.01cm">pthread_mutex_lock(&amp;mut);
while (x &lt;= y) {
pthread_cond_wait(&amp;cond, &amp;mut);
}
/* operate on x and y */
pthread_mutex_unlock(&amp;mut);</PRE><BLOCKQUOTE STYLE="margin-left: 3.01cm">
Modifications on <I>x</I> and <I>y</I> that may cause <I>x</I> to
become greater than <I>y</I> should signal the condition if needed:
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1.01cm">pthread_mutex_lock(&amp;mut);
/* modify x and y */
if (x &gt; y) pthread_cond_broadcast(&amp;cond);
pthread_mutex_unlock(&amp;mut);</PRE><BLOCKQUOTE STYLE="margin-left: 3.01cm">
If it can be proved that at most one waiting thread needs to be waken
up (for instance, if there are only two threads communicating through
<I>x</I> and <I>y</I>), <B>pthread_cond_signal</B> can be used as a
slightly more efficient alternative to <B>pthread_cond_broadcast</B>.
If in doubt, use <B>pthread_cond_broadcast</B>.
</BLOCKQUOTE>
<BLOCKQUOTE STYLE="margin-left: 3.01cm">To wait for <I>x</I> to
become greater than <I>y</I> with a timeout of 5 seconds, do:
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1.01cm">struct timeval now;
struct timespec timeout;
int retcode;
pthread_mutex_lock(&amp;mut);
gettimeofday(&amp;now);
timeout.tv_sec = now.tv_sec + 5;
timeout.tv_nsec = now.tv_usec * 1000;
retcode = 0;
while (x &lt;= y &amp;&amp; retcode != ETIMEDOUT) {
retcode = pthread_cond_timedwait(&amp;cond, &amp;mut, &amp;timeout);
}
if (retcode == ETIMEDOUT) {
/* timeout occurred */
} else {
/* operate on x and y */
}
pthread_mutex_unlock(&amp;mut);</PRE>
<HR>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
<B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Async-signal
Safety</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm; margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 0cm"><A HREF="#sect9" NAME="toc9">Example</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

98
3rdparty/pthreads4w/manual/pthread_condattr_init.html vendored
View File

@ -1,98 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CONDATTR(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;16375600">
<META NAME="CHANGED" CONTENT="20050504;16570300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_condattr_init, pthread_condattr_destroy - condition
creation
</P>
<P>attributes
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_condattr_init(pthread_condattr_t *</B><I>attr</I><B>);</B>
</P>
<P><B>int pthread_condattr_destroy(pthread_condattr_t *</B><I>attr</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Condition attributes can be specified at condition creation time,
by passing a condition attribute object as second argument to
<A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> .
Passing <B>NULL</B> is equivalent to passing a condition attribute
object with all attributes set to their default values.
</P>
<P><B>pthread_condattr_init</B> initializes the condition attribute
object <I>attr</I> and fills it with default values for the
attributes. <B>pthread_condattr_destroy</B> destroys a condition
attribute object, which must not be reused until it is reinitialized.</P>
<P><B>Pthreads-w32</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that the attribute routines are
implemented but that the process shared attribute is not supported.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>All condition variable functions return 0 on success and a
non-zero error code on error.</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_condattr_init</B> function returns the following
error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOMEM</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The was insufficient memory to create the attribute.<SPAN STYLE="font-weight: medium">
</SPAN>
</DD></DL>
</DL>
<P>
The <B>pthread_condattr_destroy</B> function returns the following
error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>attr</I> argument is not valid.<SPAN STYLE="font-weight: medium">
</SPAN>
</DD></DL>
</DL>
<H2>
<A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> .
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">See Also</A>
</P>
</UL>
</BODY>
</HTML>

153
3rdparty/pthreads4w/manual/pthread_condattr_setpshared.html vendored
View File

@ -1,153 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_CONDATTR_GETPSHARED&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;17542300">
<META NAME="CHANGED" CONTENT="20050505;18293100">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_condattr_getpshared, pthread_condattr_setpshared - get and
set the process-shared condition variable attributes
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_condattr_getpshared(const pthread_condattr_t
*restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
<BR>int pthread_condattr_setpshared(pthread_condattr_t *</B><I>attr</I><B>,
int</B> <I>pshared</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_condattr_getpshared</B> function shall obtain the
value of the <I>process-shared</I> attribute from the attributes
object referenced by <I>attr</I>. The <B>pthread_condattr_setpshared</B>
function shall set the <I>process-shared</I> attribute in an
initialized attributes object referenced by <I>attr</I>.
</P>
<P>The <I>process-shared</I> attribute is set to
<B>PTHREAD_PROCESS_SHARED</B> to permit a condition variable to be
operated upon by any thread that has access to the memory where the
condition variable is allocated, even if the condition variable is
allocated in memory that is shared by multiple processes. If the
<I>process-shared</I> attribute is <B>PTHREAD_PROCESS_PRIVATE</B>,
the condition variable shall only be operated upon by threads created
within the same process as the thread that initialized the condition
variable; if threads of differing processes attempt to operate on
such a condition variable, the behavior is undefined. The default
value of the attribute is <B>PTHREAD_PROCESS_PRIVATE</B>.
</P>
<P><B>Pthreads-w32</B> defines _<B>POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines are implemented but
that the process shared attribute is not supported.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_condattr_setpshared</B> function
shall return zero; otherwise, an error number shall be returned to
indicate the error.
</P>
<P>If successful, the <B>pthread_condattr_getpshared</B> function
shall return zero and store the value of the <I>process-shared</I>
attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
parameter. Otherwise, an error number shall be returned to indicate
the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_condattr_getpshared</B> and
<B>pthread_condattr_setpshared</B> functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
The <B>pthread_condattr_setpshared</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the attribute is outside the range of
legal values for that attribute.
</DD><DT>
<B>ENOSYS</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> was <B>PTHREAD_PROCESS_SHARED</B>
(Pthreads-w32).</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines are implemented and
may be used, but do not support the process shared option.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
<A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B>(3)</A> <B>,</B>
<A HREF="pthread_condattr_init.html"><B>pthread_condattr_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

94
3rdparty/pthreads4w/manual/pthread_create.html vendored
View File

@ -1,94 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CREATE(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;19394700">
<META NAME="CHANGED" CONTENT="20050504;20140200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_create - create a new thread
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_create(pthread_t * </B><I>thread</I><B>,
pthread_attr_t * </B><I>attr</I><B>, void * (*</B><I>start_routine</I><B>)(void
*), void * </B><I>arg</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_create</B> creates a new thread of control that
executes concurrently with the calling thread. The new thread applies
the function <I>start_routine</I> passing it <I>arg</I> as first
argument. The new thread terminates either explicitly, by calling
<A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> , or
implicitly, by returning from the <I>start_routine</I> function. The
latter case is equivalent to calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A>
with the result returned by <I>start_routine</I> as exit code.
</P>
<P>The initial signal state of the new thread is inherited from it's
creating thread and there are no pending signals. <B>Pthreads-w32</B>
does not yet implement signals.</P>
<P>The <I>attr</I> argument specifies thread attributes to be applied
to the new thread. See <A HREF="pthread_attr_init.html"><B>pthread_attr_init</B>(3)</A>
for a complete list of thread attributes. The <I>attr</I> argument
can also be <B>NULL</B>, in which case default attributes are used:
the created thread is joinable (not detached) and has default (non
real-time) scheduling policy.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>On success, the identifier of the newly created thread is stored
in the location pointed by the <I>thread</I> argument, and a 0 is
returned. On error, a non-zero error code is returned.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<DL>
<DT><B>EAGAIN</B>
</DT><DL>
<DL>
<DT>
Not enough system resources to create a process for the new
thread, or<BR>more than <B>PTHREAD_THREADS_MAX</B> threads are
already active.
</DT></DL>
</DL>
</DL>
<H2>
<A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
<A HREF="pthread_attr_init.html"><B>pthread_attr_init</B>(3)</A> .
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">See Also</A>
</P>
</UL>
</BODY>
</HTML>

71
3rdparty/pthreads4w/manual/pthread_delay_np.html vendored
View File

@ -1,71 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_DELAY_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;21371500">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_delay_np – suspend the
thread for a specified period</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_delay_np (const struct timespec *</B>interval<B>);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_delay_np</B> causes a thread to delay execution for a
specific period of time. This period ends at the current time plus
the specified interval. The routine will not return before the end of
the period is reached, but may return an arbitrary amount of time
after the period has gone by. This can be due to system load, thread
priorities, and system timer granularity.</P>
<P>Specifying an interval of zero (0) seconds and zero (0)
nanoseconds is allowed and can be used to force the thread to give up
the processor or to deliver a pending cancellation request.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P><B>pthread_delay_np </B>is a cancellation point.</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P>If an error condition occurs, <B>pthread_delay_np</B> returns an
integer value indicating the type of error.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>The <B>pthread_delay_np</B> function returns the following error
code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm">
The value specified by interval is invalid.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

90
3rdparty/pthreads4w/manual/pthread_detach.html vendored
View File

@ -1,90 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_DETACH(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.0 (Linux)">
<META NAME="CREATED" CONTENT="20050504;18010700">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20060408;9255600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_detach - put a running thread in the detached state
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_detach(pthread_t </B><I>th</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_detach</B> puts the thread <I>th</I> in the detached
state. This guarantees that the resources consumed by <I>th</I> will
be freed immediately when <I>th</I> terminates. However, this
prevents other threads from synchronizing on the termination of <I>th</I>
using <B>pthread_join</B>. If, when <B>pthread_detach</B> is called,
<I>th</I> has already terminated, all of <I>th</I>'s remaining
resources will be freed.</P>
<P>A thread can be created initially in the detached state, using the
<B>detachstate</B> attribute to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
. In contrast, <B>pthread_detach</B> applies to threads created in
the joinable state, and which need to be put in the detached state
later.
</P>
<P>After <B>pthread_detach</B> completes, subsequent attempts to
perform <B>pthread_join</B> on <I>th</I> will fail. If another thread
is already joining the thread <I>th</I> at the time <B>pthread_detach</B>
is called, <I>th</I> will be detached and <B>pthread_join</B> will
eventually return when <I>th</I> terminates but may not return with
<I>th</I>'s correct return code.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>On success, 0 is returned. On error, a non-zero error code is
returned.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<DL>
<DT><B>ESRCH</B>
</DT><DD>
No thread could be found corresponding to that specified by <I>th</I>
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
the thread <I>th</I> is already in the detached state
</DD></DL>
<H2>
<A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with Pthreads-w32.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
<A HREF="pthread_attr_init.html"><B>pthread_attr_setdetachstate</B>(3)</A>
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">See Also</A>
</P>
</UL>
</BODY>
</HTML>

48
3rdparty/pthreads4w/manual/pthread_equal.html vendored
View File

@ -1,48 +0,0 @@
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
<html>
<head>
<title>PTHREAD_EQUAL(3) manual page</title>
</head>
<body bgcolor='white'>
<a href='#toc'>Table of Contents</a><p>
<p>
<h2><a name='sect0' href='#toc0'>Name</a></h2>
pthread_equal - compare two thread identifiers
<p>
<h2><a name='sect1' href='#toc1'>Synopsis</a></h2>
<b>#include &lt;pthread.h&gt;</b>
<p> <b>int pthread_equal(pthread_t </b><i>thread1</i><b>, pthread_t </b><i>thread2</i><b>);</b>
<p>
<h2><a name='sect2' href='#toc2'>Description</a></h2>
<b>pthread_equal</b>
determines if two thread identifiers refer to the same thread.
<p>
<h2><a name='sect3' href='#toc3'>Return Value</a></h2>
A
non-zero value is returned if <i>thread1</i> and <i>thread2</i> refer to the same thread.
Otherwise, 0 is returned.
<p>
<h2><a name='sect4' href='#toc4'>Author</a></h2>
Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
<p>
<h2><a name='sect5' href='#toc5'>See Also</a></h2>
<a href='file:pthread_self.html'><b>pthread_self</b>(3)</a>
.
<p>
<hr><p>
<a name='toc'><b>Table of Contents</b></a><p>
<ul>
<li><a name='toc0' href='#sect0'>Name</a></li>
<li><a name='toc1' href='#sect1'>Synopsis</a></li>
<li><a name='toc2' href='#sect2'>Description</a></li>
<li><a name='toc3' href='#sect3'>Return Value</a></li>
<li><a name='toc4' href='#sect4'>Author</a></li>
<li><a name='toc5' href='#sect5'>See Also</a></li>
</ul>
</body>
</html>

59
3rdparty/pthreads4w/manual/pthread_exit.html vendored
View File

@ -1,59 +0,0 @@
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
<html>
<head>
<title>PTHREAD_EXIT(3) manual page</title>
</head>
<body bgcolor='white'>
<a href='#toc'>Table of Contents</a><p>
<p>
<h2><a name='sect0' href='#toc0'>Name</a></h2>
pthread_exit - terminate the calling thread
<p>
<h2><a name='sect1' href='#toc1'>Synopsis</a></h2>
<b>#include &lt;pthread.h&gt;</b>
<p> <b>void pthread_exit(void *</b><i>retval</i><b>);</b>
<p>
<h2><a name='sect2' href='#toc2'>Description</a></h2>
<b>pthread_exit</b> terminates the
execution of the calling thread. All cleanup handlers that have been set
for the calling thread with <a href='file:pthread_cleanup_push.html'><b>pthread_cleanup_push</b>(3)</a>
are executed in reverse
order (the most recently pushed handler is executed first). Finalization
functions for thread-specific data are then called for all keys that have
non- <b>NULL</b> values associated with them in the calling thread (see <a href='file:pthread_key_create.html'><b>pthread_key_create</b>(3)</a>
).
Finally, execution of the calling thread is stopped.
<p> The <i>retval</i> argument
is the return value of the thread. It can be consulted from another thread
using <a href='file:pthread_join.html'><b>pthread_join</b>(3)</a>
.
<p>
<h2><a name='sect3' href='#toc3'>Return Value</a></h2>
The <b>pthread_exit</b> function never returns.
<p>
<h2><a name='sect4' href='#toc4'>Author</a></h2>
Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
<p>
<h2><a name='sect5' href='#toc5'>See Also</a></h2>
<a href='file:pthread_create.html'><b>pthread_create</b>(3)</a>
, <a href='file:pthread_join.html'><b>pthread_join</b>(3)</a>
.
<p>
<hr><p>
<a name='toc'><b>Table of Contents</b></a><p>
<ul>
<li><a name='toc0' href='#sect0'>Name</a></li>
<li><a name='toc1' href='#sect1'>Synopsis</a></li>
<li><a name='toc2' href='#sect2'>Description</a></li>
<li><a name='toc3' href='#sect3'>Return Value</a></li>
<li><a name='toc4' href='#sect4'>Author</a></li>
<li><a name='toc5' href='#sect5'>See Also</a></li>
</ul>
</body>
</html>

76
3rdparty/pthreads4w/manual/pthread_getunique_np.html vendored
View File

@ -1,76 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_GETW32THREADHANDLE_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20110326;18290500">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
<STYLE TYPE="text/css">
<!--
H4.cjk { font-family: "AR PL UMing CN" }
H4.ctl { font-family: "Lohit Devanagari" }
H2.cjk { font-family: "AR PL UMing CN" }
H2.ctl { font-family: "Lohit Devanagari" }
-->
</STYLE>
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
<A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: normal">pthread_getunique_np – get the
unique sequence number associated with a thread</P>
<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>unsigned long long pthread_getunique_np(pthread_t</B> <I>thread</I><B>);</B></P>
<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Returns the <B>unique </B><SPAN STYLE="font-weight: normal">64 bit
sequence number</SPAN> assigned to <I>thread</I>.</P>
<P>In <B>Pthreads-win32:</B></P>
<UL>
<LI><P>the value returned is not reused after the thread terminates
so it is unique for the life of the process</P>
<LI><P>Windows native threads may obtain their own POSIX thread
sequence number by first retrieving their <B>pthread_t</B> handle
via <B>pthread_self</B> to use as the <I>thread</I> argument.</P>
</UL>
<P>This function was added for source code compatibility with some
other POSIX threads implementations.</P>
<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P><B>pthread_getunique_np</B> returns the unique sequence number for
<I>thread</I>.</P>
<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>None.</P>
<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

57
3rdparty/pthreads4w/manual/pthread_getw32threadhandle_np.html vendored
View File

@ -1,57 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_GETW32THREADHANDLE_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;21523500">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_getw32threadhandle_np – get
the Win32 thread handle associated with a thread</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>HANDLE pthread_getw32threadhandle_np(pthread_t</B> <I>thread</I><B>);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Returns the Win32 native thread <B>HANDLE</B> that the POSIX
thread <I>thread</I> is running as.</P>
<P>Applications can use the Win32 handle to set Win32 specific
attributes of the thread.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P><B>pthread_getw32threadhandle_np</B> returns the Win32 native
thread <B>HANDLE</B> for the specified POSIX thread <I>thread</I>.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>None.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

118
3rdparty/pthreads4w/manual/pthread_join.html vendored
View File

@ -1,118 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_JOIN(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;18232700">
<META NAME="CHANGED" CONTENT="20050504;18421400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_join - wait for termination of another thread
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_join(pthread_t </B><I>th</I><B>, void
**</B><I>thread_return</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_join</B> suspends the execution of the calling thread
until the thread identified by <I>th</I> terminates, either by
calling <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> or by
being cancelled.
</P>
<P>If <I>thread_return</I> is not <B>NULL</B>, the return value of <I>th</I>
is stored in the location pointed to by <I>thread_return</I>. The
return value of <I>th</I> is either the argument it gave to
<A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> , or
<B>PTHREAD_CANCELED</B> if <I>th</I> was cancelled.
</P>
<P>The joined thread <B>th</B> must be in the joinable state: it must
not have been detached using <A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A>
or the <B>PTHREAD_CREATE_DETACHED</B> attribute to <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
.
</P>
<P>When a joinable thread terminates, its memory resources (thread
descriptor and stack) are not deallocated until another thread
performs <B>pthread_join</B> on it. Therefore, <B>pthread_join</B>
must be called once for each joinable thread created to avoid memory
leaks.
</P>
<P>At most one thread can wait for the termination of a given thread.
Calling <B>pthread_join</B> on a thread <I>th</I> on which another
thread is already waiting for termination returns an error.
</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P><B>pthread_join</B> is a cancellation point. If a thread is
cancelled while suspended in <B>pthread_join</B>, the thread
execution resumes immediately and the cancellation is executed
without waiting for the <I>th</I> thread to terminate. If
cancellation occurs during <B>pthread_join</B>, the <I>th</I> thread
remains not joined.
</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P>On success, the return value of <I>th</I> is stored in the
location pointed to by <I>thread_return</I>, and 0 is returned. On
error, a non-zero error code is returned.
</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<DL>
<DT><B>ESRCH</B>
</DT><DD>
No thread could be found corresponding to that specified by <I>th</I>.
</DD><DT>
<B>EINVAL</B>
</DT><DD>
The <I>th</I> thread has been detached.
</DD><DT>
<B>EINVAL</B>
</DT><DD>
Another thread is already waiting on termination of <I>th</I>.
</DD><DT>
<B>EDEADLK</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The <I>th</I> argument refers to the calling thread.
</DD></DL>
<H2>
<A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<H2><A HREF="#toc7" NAME="sect7">See Also</A></H2>
<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
<A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> ,
<A HREF="pthread_attr_setdetachstate.html"><B>pthread_attr_setdetachstate</B>(3)</A>
, <A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
, <A HREF="pthread_key_create.html"><B>pthread_key_create</B>(3)</A>
.
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
</P>
<LI><P><A HREF="#sect7" NAME="toc7">See Also</A>
</P>
</UL>
</BODY>
</HTML>

211
3rdparty/pthreads4w/manual/pthread_key_create.html vendored
View File

@ -1,211 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_SPECIFIC(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;18425400">
<META NAME="CHANGED" CONTENT="20050509;18220200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_key_create, pthread_key_delete, pthread_setspecific,
pthread_getspecific - management of thread-specific data
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_key_create(pthread_key_t *</B><I>key</I><B>, void
(*</B><I>destr_function</I><B>) (void *));</B>
</P>
<P><B>int pthread_key_delete(pthread_key_t </B><I>key</I><B>);</B>
</P>
<P><B>int pthread_setspecific(pthread_key_t </B><I>key</I><B>, const
void *</B><I>pointer</I><B>);</B>
</P>
<P><B>void * pthread_getspecific(pthread_key_t </B><I>key</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Programs often need global or static variables that have different
values in different threads. Since threads share one memory space,
this cannot be achieved with regular variables. Thread-specific data
is the POSIX threads answer to this need.
</P>
<P>Each thread possesses a private memory block, the thread-specific
data area, or TSD area for short. This area is indexed by TSD keys.
The TSD area associates values of type <B>void *</B> to TSD keys. TSD
keys are common to all threads, but the value associated with a given
TSD key can be different in each thread.
</P>
<P>For concreteness, the TSD areas can be viewed as arrays of <B>void
*</B> pointers, TSD keys as integer indices into these arrays, and
the value of a TSD key as the value of the corresponding array
element in the calling thread.
</P>
<P>When a thread is created, its TSD area initially associates <B>NULL</B>
with all keys.
</P>
<P><B>pthread_key_create</B> allocates a new TSD key. The key is
stored in the location pointed to by <I>key</I>. There is a limit of
<B>PTHREAD_KEYS_MAX</B> on the number of keys allocated at a given
time. The value initially associated with the returned key is <B>NULL</B>
in all currently executing threads.
</P>
<P>The <I>destr_function</I> argument, if not <B>NULL</B>, specifies
a destructor function associated with the key. When a thread
terminates via <B>pthread_exit</B> or by cancellation, <I>destr_function</I>
is called with arguments the value associated with the key in that
thread. The <I>destr_function</I> is not called if that value is <B>NULL</B><SPAN STYLE="font-weight: medium">
or the key has been deleted</SPAN>. The order in which destructor
functions are called at thread termination time is unspecified.
</P>
<P>Before the destructor function is called, the <B>NULL</B> value is
associated with the key in the current thread. A destructor function
might, however, re-associate non- <B>NULL</B> values to that key or
some other key. To deal with this, if after all the destructors have
been called for all non- <B>NULL</B> values, there are still some
non- <B>NULL</B> values with associated destructors, then the process
is repeated.</P>
<P><B>pthread_key_delete</B> deallocates a TSD key. It does not check
whether non- <B>NULL</B> values are associated with that key in the
currently executing threads, nor call the destructor function
associated with the key.
</P>
<P><B>pthread_setspecific</B> changes the value associated with <I>key</I>
in the calling thread, storing the given <I>pointer</I> instead.
</P>
<P><B>pthread_getspecific</B> returns the value currently associated
with <I>key</I> in the calling thread.
</P>
<P>The routines <B>pthread_setspecific</B>, <B>pthread_getspecific</B>,
and <B>pthread_key_delete</B> can be called from <I>destr_function</I>
targeting any valid key including the key on which <I>destr_function</I>
is currently operating. If <B>pthread_getspecific</B> is called on
the key whose thread specific data is being destroyed, the value NULL
is returned, unless <B>pthread_setspecific</B> was called previously
on that key from within <I>destr_function</I> to set the value to
non-NULL. For some implementations the effect of calling
<B>pthread_setspecific</B> from within <I>destr_function</I> can be
either memory leakage or infinite loops if <I>destr_function</I> has
already been called at least <B>PTHREAD_DESTRUCTOR_ITERATIONS</B>
times.</P>
<P STYLE="font-weight: medium"><B>Pthreads-w32</B> stops running key
<I>destr_function</I> routines after <B>PTHREAD_DESTRUCTOR_ITERATIONS</B>
iterations, even if some non- <B>NULL</B> values with associated
descriptors remain. If memory is allocated and associated with a key
from within <I>destr_function</I>, that memory may not be reclaimed
because that key's <I>destr_function</I>, may not run again.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><B>pthread_key_create</B>, <B>pthread_key_delete</B>, and
<B>pthread_setspecific</B> return 0 on success and a non-zero error
code on failure. If successful, <B>pthread_key_create</B> stores the
newly allocated key in the location pointed to by its <I>key</I>
argument.
</P>
<P><B>pthread_getspecific</B> returns the value associated with <I>key</I>
on success, and <B>NULL</B> on error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P><B>pthread_key_create</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 5cm">
<B>PTHREAD_KEYS_MAX</B> keys are already allocated
</BLOCKQUOTE>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOMEM</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 5cm">
Insufficient memory to allocate the key.
</BLOCKQUOTE>
<P><B>pthread_key_delete</B> and <B>pthread_setspecific</B> return
the following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>key</I> is not a valid, allocated TSD key
</DD></DL>
</DL>
<P>
<B>pthread_getspecific</B> returns <B>NULL</B> if <I>key</I> is not a
valid, allocated TSD key.
</P>
<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_create.html">pthread_create(3)</A> ,
<A HREF="pthread_exit.html">pthread_exit(3)</A> ,
<A HREF="pthread_cancel.html">pthread_testcancel(3)</A> .
</P>
<H2><A HREF="#toc7" NAME="sect7">Example</A></H2>
<P>The following code fragment allocates a thread-specific array of
100 characters, with automatic reclamation at thread exit:
</P>
<BLOCKQUOTE><BR><BR>
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1cm; margin-right: 1cm">/* Key for the thread-specific buffer */
static pthread_key_t buffer_key;
/* Once-only initialisation of the key */
static pthread_once_t buffer_key_once = PTHREAD_ONCE_INIT;
/* Allocate the thread-specific buffer */
void buffer_alloc(void)
{
pthread_once(&amp;buffer_key_once, buffer_key_alloc);
pthread_setspecific(buffer_key, malloc(100));
}
/* Return the thread-specific buffer */
char * get_buffer(void)
{
return (char *) pthread_getspecific(buffer_key);
}
/* Allocate the key */
static void buffer_key_alloc()
{
pthread_key_create(&amp;buffer_key, buffer_destroy);
}
/* Free the thread-specific buffer */
static void buffer_destroy(void * buf)
{
free(buf);
}</PRE>
<HR>
<BLOCKQUOTE STYLE="margin-left: 0cm; margin-right: 0cm"><A NAME="toc"></A>
<B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Example</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

152
3rdparty/pthreads4w/manual/pthread_kill.html vendored
View File

@ -1,152 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_SIGNAL(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;18500100">
<META NAME="CHANGED" CONTENT="20050504;23005800">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_sigmask, pthread_kill, sigwait - handling of signals in
threads
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B> <BR><B>#include &lt;signal.h&gt;</B>
</P>
<P><B>int pthread_sigmask(int </B><I>how</I><B>, const sigset_t
*</B><I>newmask</I><B>, sigset_t *</B><I>oldmask</I><B>);</B>
</P>
<P><B>int pthread_kill(pthread_t </B><I>thread</I><B>, int </B><I>signo</I><B>);</B>
</P>
<P><B>int sigwait(const sigset_t *</B>set, <B>int</B> *sig);</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_sigmask</B> changes the signal mask for the calling
thread as described by the <I>how</I> and <I>newmask</I> arguments.
If <I>oldmask</I> is not <B>NULL</B>, the previous signal mask is
stored in the location pointed to by <I>oldmask</I>. <B>Pthreads-w32</B>
implements this function but no other function uses the signal mask
yet.</P>
<P>The meaning of the <I>how</I> and <I>newmask</I> arguments is the
same as for <B><SPAN STYLE="font-style: normal">sigprocmask</SPAN></B>(2).
If <I>how</I> is <B>SIG_SETMASK</B>, the signal mask is set to
<I>newmask</I>. If <I>how</I> is <B>SIG_BLOCK</B>, the signals
specified to <I>newmask</I> are added to the current signal mask. If
<I>how</I> is <B>SIG_UNBLOCK</B>, the signals specified to <I>newmask</I>
are removed from the current signal mask.
</P>
<P>Recall that signal masks are set on a per-thread basis, but signal
actions and signal handlers, as set with <B>sigaction</B>(2), are
shared between all threads.
</P>
<P><B>pthread_kill</B> send signal number <I>signo</I> to the thread
<I>thread</I>. <B>Pthreads-w32</B> only supports signal number 0,
which does not send any signal but causes <B>pthread_kill</B> to
return an error if <I>thread</I> is not valid.</P>
<P><B>sigwait</B> suspends the calling thread until one of the
signals in <I>set</I> is delivered to the calling thread. It then
stores the number of the signal received in the location pointed to
by <I>sig</I> and returns. The signals in <I>set</I> must be blocked
and not ignored on entrance to <B>sigwait</B>. If the delivered
signal has a signal handler function attached, that function is <I>not</I>
called. <B>Pthreads-w32</B> implements this function as a
cancellation point only - it does not wait for any signals and does
not change the location pointed to by <I>sig</I>.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P><B>sigwait</B> is a cancellation point.
</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P>On success, 0 is returned. On failure, a non-zero error code is
returned.
</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>The <B>pthread_sigmask</B> function returns the following error
codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>how</I> is not one of <B>SIG_SETMASK</B>, <B>SIG_BLOCK</B>, or
<B>SIG_UNBLOCK</B>
</DD></DL>
</DL>
<P>
The <B>pthread_kill</B> function returns the following error codes on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>signo</I> is not a valid signal number or is unsupported.</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the thread <I>thread</I> does not exist (e.g. it has already
terminated)
</DD></DL>
</DL>
<P>
The <B>sigwait</B> function never returns an error.
</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc7" NAME="sect7">See Also</A></H2>
<P>
</P>
<H2><A HREF="#toc8" NAME="sect8">Notes</A></H2>
<P>In any implementation, for <B>sigwait</B> to work reliably, the
signals being waited for must be blocked in all threads, not only in
the calling thread, since otherwise the POSIX semantics for signal
delivery do not guarantee that it’s the thread doing the <B>sigwait</B>
that will receive the signal. The best way to achieve this is to
block those signals before any threads are created, and never unblock
them in the program other than by calling <B>sigwait</B>. This works
because all threads inherit their initial sigmask from their creating
thread.</P>
<H2><A HREF="#toc9" NAME="sect9">Bugs</A></H2>
<P><B>Pthreads-w32</B> does not implement signals yet and so these
routines have almost no use except to prevent the compiler or linker
from complaining. <B>pthread_kill</B> is useful in determining if the
thread is a valid thread, but since many threads implementations
reuse thread IDs, the valid thread may no longer be the thread you
think it is, and so this method of determining thread validity is not
portable, and very risky. <B>Pthreads-w32</B> from version 1.0.0
onwards implements pseudo-unique thread IDs, so applications that use
this technique (but really shouldn't) have some protection.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Author</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">See
Also</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Notes</A>
</P>
<LI><P><A HREF="#sect9" NAME="toc9">Bugs</A>
</P>
</UL>
</BODY>
</HTML>

356
3rdparty/pthreads4w/manual/pthread_mutex_init.html vendored
View File

@ -1,356 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_MUTEX(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2 (Linux)">
<META NAME="CREATED" CONTENT="20050505;5000">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20110326;15072100">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
<STYLE TYPE="text/css">
<!--
H4.cjk { font-family: "AR PL UMing CN" }
H4.ctl { font-family: "Lohit Devanagari" }
H2.cjk { font-family: "AR PL UMing CN" }
H2.ctl { font-family: "Lohit Devanagari" }
PRE.cjk { font-family: "AR PL UMing CN", monospace }
PRE.ctl { font-family: "Lohit Devanagari", monospace }
-->
</STYLE>
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
<A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock,
pthread_mutex_timedlock, pthread_mutex_unlock,
pthread_mutex_consistent, pthread_mutex_destroy - operations on
mutexes
</P>
<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>#include &lt;time.h&gt;</B></P>
<P><B>pthread_mutex_t </B><I>fastmutex</I> <B>=
PTHREAD_MUTEX_INITIALIZER;</B>
</P>
<P><B>pthread_mutex_t </B><I>recmutex</I> <B>=
PTHREAD_RECURSIVE_MUTEX_INITIALIZER;</B>
</P>
<P><B>pthread_mutex_t </B><I>errchkmutex</I> <B>=
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER;</B>
</P>
<P><B>pthread_mutex_t </B><I>recmutex</I> <B>=
PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;</B>
</P>
<P><B>pthread_mutex_t </B><I>errchkmutex</I> <B>=
PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;</B>
</P>
<P><B>int pthread_mutex_init(pthread_mutex_t *</B><I>mutex</I><B>,
const pthread_mutexattr_t *</B><I>mutexattr</I><B>);</B>
</P>
<P><B>int pthread_mutex_lock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<P><B>int pthread_mutex_trylock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<P><B>int pthread_mutex_timedlock(pthread_mutex_t *</B><I>mutex,
</I><B>const struct timespec *</B><I>abs_timeout</I><B>);</B>
</P>
<P><B>int pthread_mutex_unlock(pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<P><B>int pthread_mutex_consistent(pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<P><B>int pthread_mutex_destroy(pthread_mutex_t *</B><I>mutex</I><B>);</B>
</P>
<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>A mutex is a MUTual EXclusion device, and is useful for protecting
shared data structures from concurrent modifications, and
implementing critical sections and monitors.
</P>
<P>A mutex has two possible states: unlocked (not owned by any
thread), and locked (owned by one thread). A mutex can never be owned
by two different threads simultaneously. A thread attempting to lock
a mutex that is already locked by another thread is suspended until
the owning thread unlocks the mutex first.
</P>
<P><B>pthread_mutex_init</B> initializes the mutex object pointed to
by <I>mutex</I> according to the mutex attributes specified in
<I>mutexattr</I>. If <I>mutexattr</I> is <B>NULL</B>, default
attributes are used instead.
</P>
<P>The type of a mutex determines whether it can be locked again by a
thread that already owns it. The default type is “normal”. See
<A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B>(3)</A>
for more information on mutex attributes.
</P>
<P>Variables of type <B>pthread_mutex_t</B> can also be initialized
statically, using the constants <B>PTHREAD_MUTEX_INITIALIZER</B> (for
normal “fast” mutexes), <B>PTHREAD_RECURSIVE_MUTEX_INITIALIZER</B>
(for recursive mutexes), and <B>PTHREAD_ERRORCHECK_MUTEX_INITIALIZER</B>
(for error checking mutexes). <SPAN STYLE="font-weight: normal">In
the </SPAN><B>Pthreads-w32</B> <SPAN STYLE="font-weight: normal">implementation,
an application should still call </SPAN><B>pthread_mutex_destroy</B>
<SPAN STYLE="font-weight: normal">at some point to ensure that any
resources consumed by the mutex are released.</SPAN></P>
<P><SPAN STYLE="font-weight: normal">Any mutex type can be
initialized as a </SPAN><B>robust mutex</B><SPAN STYLE="font-weight: normal">.
See </SPAN><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B><SPAN STYLE="font-weight: normal">(3)</SPAN></A>
<SPAN STYLE="font-weight: normal">for more information as well as the
section </SPAN><I><U><SPAN STYLE="font-weight: normal">Robust Mutexes</SPAN></U></I>
<SPAN STYLE="font-weight: normal">below.</SPAN></P>
<P><B>pthread_mutex_lock</B> locks the given mutex. If the mutex is
currently unlocked, it becomes locked and owned by the calling
thread, and <B>pthread_mutex_lock</B> returns immediately. If the
mutex is already locked by another thread, <B>pthread_mutex_lock</B>
suspends the calling thread until the mutex is unlocked.</P>
<P>If the mutex is already locked by the calling thread, the behavior
of <B>pthread_mutex_lock</B> depends on the type of the mutex. If the
mutex is of the “normal” type, the calling thread is suspended
until the mutex is unlocked, thus effectively causing the calling
thread to deadlock. If the mutex is of the ‘‘error checking’’
type, <B>pthread_mutex_lock</B> returns immediately with the error
code <B>EDEADLK</B>. If the mutex is of the ‘‘recursive’’
type, <B>pthread_mutex_lock</B> succeeds and returns immediately,
recording the number of times the calling thread has locked the
mutex. An equal number of <B>pthread_mutex_unlock</B> operations must
be performed before the mutex returns to the unlocked state.
</P>
<P><B>pthread_mutex_trylock</B> behaves identically to
<B>pthread_mutex_lock</B>, except that it does not block the calling
thread if the mutex is already locked by another thread (or by the
calling thread in the case of a “normal” or “<SPAN STYLE="font-style: normal">errorcheck</SPAN>”
mutex). Instead, <B>pthread_mutex_trylock</B> returns immediately
with the error code <B>EBUSY</B>.
</P>
<P><B>pthread_mutex_timedlock</B> behaves identically to
<B>pthread_mutex_lock</B>, except that if it cannot acquire the lock
before the <I>abs_timeout</I> time, the call returns with the error
code <B>ETIMEDOUT</B>. If the mutex can be locked immediately it is,
and the <B>abs_timeout</B> parameter is ignored.</P>
<P><B>pthread_mutex_consistent</B> may only be called for
<B>PTHREAD_MUTEX_ROBUST</B> mutexes. It simply marks the mutex as
consistent. See <I><U>Robust Mutexes</U></I> below.</P>
<P><B>pthread_mutex_unlock</B> unlocks the given mutex. The mutex is
assumed to be locked and owned by the calling thread on entrance to
<B>pthread_mutex_unlock</B>. If the mutex is of the “normal”
type, <B>pthread_mutex_unlock</B> always returns it to the unlocked
state. If it is of the ‘‘recursive’’ type, it decrements the
locking count of the mutex (number of <B>pthread_mutex_lock</B>
operations performed on it by the calling thread), and only when this
count reaches zero is the mutex actually unlocked. In <B>Pthreads-win32</B>,
non-robust normal or default mutex types do not check the owner of
the mutex. For all types of robust mutexes the owner is checked and
an error code is returned if the calling thread does not own the
mutex.</P>
<P>On ‘‘error checking’’ mutexes, <B>pthread_mutex_unlock</B>
actually checks at run-time that the mutex is locked on entrance, and
that it was locked by the same thread that is now calling
<B>pthread_mutex_unlock</B>. If these conditions are not met, an
error code is returned and the mutex remains unchanged. ‘‘Normal’’
[non-robust] mutexes perform no such checks, thus allowing a locked
mutex to be unlocked by a thread other than its owner. This is
non-portable behavior and is not meant to be used as a feature.</P>
<P><B>pthread_mutex_destroy</B> destroys a mutex object, freeing the
resources it might hold. The mutex must be unlocked on entrance.</P>
<H2 CLASS="western"><A HREF="#toc10" NAME="sect10">Robust Mutexes</A></H2>
<P>If the mutex is <B>PTHREAD_MUTEX_ROBUST</B> and the owning thread
terminates without unlocking the mutex the implementation will wake
one waiting thread, if any. The next thread to acquire the mutex will
receive the error code <B>EOWNERDEAD</B><SPAN STYLE="font-weight: normal">,
in which case that thread should if possible ensure that the state
protected by the mutex is consistent and then call
</SPAN><B>pthread_mutex_consistent</B> <SPAN STYLE="font-weight: normal">before
unlocking. The mutex may then be used normally from then on.</SPAN></P>
<P><SPAN STYLE="font-weight: normal">If the thread cannot recover the
state then it must call </SPAN><B>pthread_mutex_unlock</B><SPAN STYLE="font-weight: normal">
without calling </SPAN><B>pthread_mutex_consistent</B><SPAN STYLE="font-weight: normal">.
This will mark the mutex as unusable and wake all currently waiting
threads with the return code </SPAN><B>ENOTRECOVERABLE</B><SPAN STYLE="font-weight: normal">.
The error indicates that the mutex is no longer usable and any
threads that receive this error code from any lock operation have not
acquired the mutex. The mutex can be made consistent by calling
</SPAN><B>pthread_mutex_destroy</B> <SPAN STYLE="font-weight: normal">to
uninitialize the mutex, and calling </SPAN><B>pthread_mutex_int</B>
<SPAN STYLE="font-weight: normal">to reinitialize the mutex. However,
the state that was protected by the mutex remains inconsistent and
some form of application recovery is required.</SPAN></P>
<P><SPAN STYLE="font-weight: normal">If a thread that receives the
</SPAN><B>EOWNERDEAD</B> <SPAN STYLE="font-weight: normal">error code
itself terminates without unlocking the mutex then this behaviour
repeats for the next acquiring thread.</SPAN></P>
<P><SPAN STYLE="font-weight: normal">Applications must ensure that
they check the return values from all calls targeting robust mutexes.</SPAN></P>
<P STYLE="font-weight: normal">Robust mutexes are slower because they
require some additional overhead, however they are not very much
slower than the non-robust recursive type.</P>
<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None of the mutex functions is a cancellation point, not even
<B>pthread_mutex_lock</B>, in spite of the fact that it can suspend a
thread for arbitrary durations. This way, the status of mutexes at
cancellation points is predictable, allowing cancellation handlers to
unlock precisely those mutexes that need to be unlocked before the
thread stops executing. Consequently, threads using deferred
cancellation should never hold a mutex for extended periods of time.
</P>
<H2 CLASS="western"><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
<P>The mutex functions are not async-signal safe. What this means is
that they should not be called from a signal handler. In particular,
calling <B>pthread_mutex_lock</B> or <B>pthread_mutex_unlock</B> from
a signal handler may deadlock the calling thread.
</P>
<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
<P><B>pthread_mutex_init</B> always returns 0. The other mutex
functions return 0 on success and a non-zero error code on error.
</P>
<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">Errors</A></H2>
<P>The <B>pthread_mutex_lock</B> function returns the following error
code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EINVAL</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex has not been properly initialized.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EDEADLK</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex is already locked by the calling thread (‘‘error
checking’’ mutexes only).
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is now locked by the calling thread after the
previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is not locked and is no longer usable after the
previous owner unlocked it without calling
pthread_mutex_consistent.</DD></DL>
<DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
The <B>pthread_mutex_trylock</B> function returns the following
error codes on error:
</DD><DL>
<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EBUSY</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex could not be acquired because it was currently locked.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EINVAL</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex has not been properly initialized.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is now locked by the calling thread after the
previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is not locked and is no longer usable after the
previous owner unlocked it without calling
pthread_mutex_consistent.</DD></DL>
</DL>
<P>
The <B>pthread_mutex_timedlock</B> function returns the following
error codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>ETIMEDOUT</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex could not be acquired before the <I>abs_timeout</I> time
arrived.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EINVAL</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex has not been properly initialized.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EOWNERDEAD</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is now locked by the calling thread after the
previous owner terminated without unlocking it.</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>ENOTRECOVERABLE</B></DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the robust mutex is not locked and is no longer usable after the
previous owner unlocked it without calling
pthread_mutex_consistent.</DD></DL>
</DL>
<P>
The <B>pthread_mutex_unlock</B> function returns the following error
code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex has not been properly initialized.
</DD><DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
<B>EPERM</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the calling thread does not own the mutex (‘‘error checking’’
mutexes only).
</DD></DL>
</DL>
<P>
The <B>pthread_mutex_destroy</B> function returns the following error
code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 0.39in; margin-bottom: 0.2in"><B>EBUSY</B>
</DT><DD STYLE="margin-right: 0.39in; margin-bottom: 0.2in">
the mutex is currently locked.
</DD></DL>
</DL>
<H2 CLASS="western">
<A HREF="#toc7" NAME="sect7">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2 CLASS="western"><A HREF="#toc8" NAME="sect8">See Also</A></H2>
<P><A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_init</B>(3)</A>
, <A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_settype</B>(3)</A>
, <A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> .
</P>
<H2 CLASS="western"><A HREF="#toc9" NAME="sect9">Example</A></H2>
<P>A shared global variable <I>x</I> can be protected by a mutex as
follows:
</P>
<PRE CLASS="western" STYLE="margin-left: 0.39in; margin-right: 0.39in">int x;
pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;</PRE><BLOCKQUOTE STYLE="margin-left: 0in; margin-right: 0in">
All accesses and modifications to <I>x</I> should be bracketed by
calls to <B>pthread_mutex_lock</B> and <B>pthread_mutex_unlock</B> as
follows:
</BLOCKQUOTE>
<PRE CLASS="western" STYLE="margin-left: 0.41in; margin-right: 0.79in">pthread_mutex_lock(&amp;mut);
/* operate on x */
pthread_mutex_unlock(&amp;mut);</PRE>
<HR>
<BLOCKQUOTE STYLE="margin-right: 2.75in"><A NAME="toc"></A><B>Table
of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect10" NAME="toc10">Robust
Mutexes</A></BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect4" NAME="toc4">Async-signal
Safety</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect6" NAME="toc6">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect7" NAME="toc7">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in; margin-bottom: 0in"><A HREF="#sect8" NAME="toc8">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-right: 2.75in"><A HREF="#sect9" NAME="toc9">Example</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

207
3rdparty/pthreads4w/manual/pthread_mutexattr_init.html vendored
View File

@ -1,207 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_MUTEXATTR(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 3.2 (Linux)">
<META NAME="CREATED" CONTENT="20050504;23040500">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20110326;13190500">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
<STYLE TYPE="text/css">
<!--
H4.cjk { font-family: "AR PL UMing CN" }
H4.ctl { font-family: "Lohit Devanagari" }
H2.cjk { font-family: "AR PL UMing CN" }
H2.ctl { font-family: "Lohit Devanagari" }
-->
</STYLE>
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4 CLASS="western">POSIX Threads for Windows – REFERENCE -
<A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2 CLASS="western"><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_mutexattr_init, pthread_mutexattr_destroy,
pthread_mutexattr_settype, pthread_mutexattr_gettype - mutex creation
attributes
</P>
<H2 CLASS="western"><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_mutexattr_init(pthread_mutexattr_t *</B><I>attr</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_destroy(pthread_mutexattr_t *</B><I>attr</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_settype(pthread_mutexattr_t *</B><I>attr</I><B>,
int </B><I>type</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_gettype(const pthread_mutexattr_t *</B><I>attr</I><B>,
int *</B><I>type</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_setkind_np(pthread_mutexattr_t *</B><I>attr</I><B>,
int </B><I>type</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_getkind_np(const pthread_mutexattr_t
*</B><I>attr</I><B>, int *</B><I>type</I><B>);</B>
</P>
<P><B>int pthread_mutexattr_setrobust(pthread_mutexattr_t *</B><I>attr</I><B>,
int</B><SPAN STYLE="font-weight: normal"> </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><B>);</B>
</P>
<P><B>int pthread_mutexattr_getrobust(pthread_mutexattr_t *</B><I>attr</I><B>,
int</B><SPAN STYLE="font-weight: normal"> </SPAN><B>*</B><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><B>);</B>
</P>
<H2 CLASS="western"><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Mutex attributes can be specified at mutex creation time, by
passing a mutex attribute object as second argument to
<A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A> .
Passing <B>NULL</B> is equivalent to passing a mutex attribute object
with all attributes set to their default values.
</P>
<P><B>pthread_mutexattr_init</B> initializes the mutex attribute
object <I>attr</I> and fills it with default values for the
attributes.
</P>
<P><B>pthread_mutexattr_destroy</B> destroys a mutex attribute
object, which must not be reused until it is reinitialized.</P>
<P><B>pthread_mutexattr_settype</B> sets the mutex type attribute in
<I>attr</I> to the value specified by <I>type</I>.
</P>
<P><B>pthread_mutexattr_gettype</B> retrieves the current value of
the mutex kind attribute in <I>attr</I> and stores it in the location
pointed to by <I>type</I>.
</P>
<P><B>Pthreads-w32</B> also recognises the following equivalent
functions that are used in Linux:</P>
<P><B>pthread_mutexattr_setkind_np</B> is an alias for
<B>pthread_mutexattr_settype</B>.
</P>
<P STYLE="font-weight: normal"><B>pthread_mutexattr_getkind_np</B> is
an alias for <B>pthread_mutexattr_gettype</B>.
</P>
<P>The following mutex types are supported:</P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_NORMAL</B> - for
‘‘fast’’ mutexes.</P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_RECURSIVE</B> - for
‘‘recursive’’ mutexes.</P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ERRORCHECK</B> - for
‘‘error checking’’ mutexes.</P>
<P>The mutex type determines what happens if a thread attempts to
lock a mutex it already owns with <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
. If the mutex is of the “normal” or “fast” type,
<A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
simply suspends the calling thread forever. If the mutex is of the
‘‘error checking’’ type, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
returns immediately with the error code <B>EDEADLK</B>. If the mutex
is of the ‘‘recursive’’ type, the call to
<A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
returns immediately with a success return code. The number of times
the thread owning the mutex has locked it is recorded in the mutex.
The owning thread must call <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
the same number of times before the mutex returns to the unlocked
state.
</P>
<P>The default mutex type is <B>PTHREAD_MUTEX_NORMAL</B></P>
<P><B>Pthreads-w32</B> also recognises the following equivalent types
that are used by Linux:</P>
<P STYLE="margin-left: 0.79in; font-weight: normal"><B>PTHREAD_MUTEX_FAST_NP</B>
– equivalent to <B>PTHREAD_MUTEX_NORMAL</B></P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_RECURSIVE_NP</B></P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ERRORCHECK_NP</B></P>
<P><B>pthread_mutexattr_setrobust</B><SPAN STYLE="font-weight: normal">
sets the robustness attribute to the value given by </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
<P><B>pthread_mutexattr_getrobust</B><SPAN STYLE="font-weight: normal">
returns the current robustness value to the location given by
*</SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
<P><SPAN STYLE="font-weight: normal">The possible values for </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
are:</SPAN></P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_STALLED</B><SPAN STYLE="font-weight: normal">
- when the owner of the mutex terminates without unlocking the mutex,
all subsequent calls to pthread_mutex_*lock() are blocked from
progress in an unspecified manner.</SPAN></P>
<P STYLE="margin-left: 0.79in"><B>PTHREAD_MUTEX_ROBUST</B><SPAN STYLE="font-weight: normal">
- when the owner of the mutex terminates without unlocking the mutex,
the mutex is unlocked. The next owner of this mutex acquires the
mutex with an error return of EOWNERDEAD.</SPAN></P>
<H2 CLASS="western"><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><SPAN STYLE="font-weight: normal">On success all functions return
0, otherwise they return an error code as follows:</SPAN></P>
<P><B>pthread_mutexattr_init</B></P>
<P STYLE="margin-left: 0.79in"><B>ENOMEM</B><SPAN STYLE="font-weight: normal">
- insufficient memory for </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">.</SPAN></P>
<P><B>pthread_mutexattr_destroy</B></P>
<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
- </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
is invalid.</SPAN></P>
<P><B>pthread_mutexattr_gettype</B></P>
<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
- </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
is invalid.</SPAN></P>
<P><B>pthread_mutexattr_settype</B></P>
<DL>
<DL>
<DL>
<DT><B>EINVAL</B><SPAN STYLE="font-weight: normal"> - </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
is invalid or </SPAN><I><SPAN STYLE="font-weight: normal">type</SPAN></I><SPAN STYLE="font-weight: normal">
is none of:</SPAN></DT><DL>
<DL>
<DT>
<B>PTHREAD_MUTEX_NORMAL<BR>PTHREAD_MUTEX_FAST_NP<BR>PTHREAD_MUTEX_RECURSIVE<BR>PTHREAD_MUTEX_RECURSIVE_NP<BR>PTHREAD_MUTEX_ERRORCHECK<BR>PTHREAD_MUTEX_ERRORCHECK_NP</B></DT></DL>
</DL>
</DL>
</DL>
<DD STYLE="margin-left: 0in">
<BR>
</DD></DL>
<P>
<B>pthread_mutexattr_getrobust</B></P>
<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
– </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
or </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
is invalid.</SPAN></P>
<P><B>pthread_mutexattr_setrobust</B></P>
<P STYLE="margin-left: 0.79in"><B>EINVAL</B><SPAN STYLE="font-weight: normal">
– </SPAN><I><SPAN STYLE="font-weight: normal">attr</SPAN></I><SPAN STYLE="font-weight: normal">
or </SPAN><I><SPAN STYLE="font-weight: normal">robust</SPAN></I><SPAN STYLE="font-weight: normal">
is invalid.</SPAN></P>
<H2 CLASS="western"><A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2 CLASS="western"><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A>
, <A HREF="pthread_mutex_lock.html"><B>pthread_mutex_lock</B>(3)</A>
, <A HREF="pthread_mutex_unlock.html"><B>pthread_mutex_unlock</B>(3)</A>
.
</P>
<H2 CLASS="western"><A HREF="#toc7" NAME="sect7"><FONT COLOR="#000080"><U>Notes</U></FONT></A></H2>
<P>For speed, <B>Pthreads-w32</B> never checks the thread ownership
of non-robust mutexes of type <B>PTHREAD_MUTEX_NORMAL</B> (or
<B>PTHREAD_MUTEX_FAST_NP</B>) when performing operations on the
mutex. It is therefore possible for one thread to lock such a mutex
and another to unlock it.</P>
<P STYLE="font-weight: normal">When developing code, it is a common
precaution to substitute the error checking type, then drop in the
normal type for release if the extra performance is required.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect5" NAME="toc5">Author</A>
</P>
<LI><P STYLE="margin-bottom: 0in"><A HREF="#sect6" NAME="toc6">See
Also</A></P>
<LI><P><A HREF="#sect7" NAME="toc7">Notes</A></P>
</UL>
</BODY>
</HTML>

151
3rdparty/pthreads4w/manual/pthread_mutexattr_setpshared.html vendored
View File

@ -1,151 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_MUTEXATTR_GETPSHARED&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;23480600">
<META NAME="CHANGED" CONTENT="20050505;18381800">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_mutexattr_getpshared, pthread_mutexattr_setpshared - get
and set the process-shared attribute
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_mutexattr_getpshared(const pthread_mutexattr_t *
restrict</B> <I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
<BR>int pthread_mutexattr_setpshared(pthread_mutexattr_t *</B><I>attr</I><B>,
int</B> <I>pshared</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_mutexattr_getpshared</B> function shall obtain the
value of the <I>process-shared</I> attribute from the attributes
object referenced by <I>attr</I>. The <B>pthread_mutexattr_setpshared</B>
function shall set the <I>process-shared</I> attribute in an
initialized attributes object referenced by <I>attr</I>.
</P>
<P>The <I>process-shared</I> attribute is set to
<B>PTHREAD_PROCESS_SHARED</B> to permit a mutex to be operated upon
by any thread that has access to the memory where the mutex is
allocated, even if the mutex is allocated in memory that is shared by
multiple processes. If the <I>process-shared</I> attribute is
<B>PTHREAD_PROCESS_PRIVATE</B>, the mutex shall only be operated upon
by threads created within the same process as the thread that
initialized the mutex; if threads of differing processes attempt to
operate on such a mutex, the behavior is undefined. The default value
of the attribute shall be <B>PTHREAD_PROCESS_PRIVATE</B>.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines are implemented but
the process shared option is not supported.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, <B>pthread_mutexattr_setpshared</B>
shall return zero; otherwise, an error number shall be returned to
indicate the error.
</P>
<P>Upon successful completion, <B>pthread_mutexattr_getpshared</B>
shall return zero and store the value of the <I>process-shared</I>
attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
parameter. Otherwise, an error number shall be returned to indicate
the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_mutexattr_getpshared</B> and
<B>pthread_mutexattr_setpshared</B> functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
The <B>pthread_mutexattr_setpshared</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the attribute is outside the range of
legal values for that attribute.
</DD><DT>
<B>ENOTSUP</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the attribute is PTHREAD_PROCESS_SHARED.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_cond_init.html"><B>pthread_cond_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A> <B>,</B>
<A HREF="pthread_mutex_init.html"><B>pthread_mutex_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_mutexattr_init.html"><B>pthread_mutexattr_destroy</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

57
3rdparty/pthreads4w/manual/pthread_num_processors_np.html vendored
View File

@ -1,57 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_NUM_PROCESSORS_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;21514100">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_num_processors_np – get the
number of processors (CPUs) in use by the process</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_num_processors_np(void);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_num_processors_np </B>returns the number of processors
in the system. This implementation actually returns the number of
processors available to the process, which can be a lower number than
the system's number, depending on the process's affinity mask.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
<P><B>pthread_num_processors_np</B> returns the number of processors
currently available to the process.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>None.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

83
3rdparty/pthreads4w/manual/pthread_once.html vendored
View File

@ -1,83 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_ONCE(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050603;463100">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_once - once-only initialization
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>pthread_once_t </B><I>once_control</I> <B>= PTHREAD_ONCE_INIT;</B>
</P>
<P><B>int pthread_once(pthread_once_t *</B><I>once_control</I><B>,
void (*</B><I>init_routine</I><B>) (void));</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The purpose of <B>pthread_once</B> is to ensure that a piece of
initialization code is executed at most once. The <I>once_control</I>
argument points to a static or extern variable statically initialized
to <B>PTHREAD_ONCE_INIT</B>.
</P>
<P>The first time <B>pthread_once</B> is called with a given
<I>once_control</I> argument, it calls <I>init_routine</I> with no
argument and changes the value of the <I>once_control</I> variable to
record that initialization has been performed. Subsequent calls to
<B>pthread_once</B> with the same <B>once_control</B> argument do
nothing.
</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>While <B>pthread_once</B> is not a cancellation point,
<I>init_routine</I> can be. The effect on <I>once_control</I> of a
cancellation inside the <I>init_routine</I> is to leave it as if
<B>pthread_once</B> had not been called by the cancelled thread.</P>
<H2><A HREF="#toc4" NAME="sect4">Return Value</A></H2>
<P STYLE="text-decoration: none"><FONT COLOR="#000000"><B>pthread_once</B>
returns 0 on success, or an error code on failure.</FONT></P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>The <B>pthread_once</B> function returns the following error code
on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm">
The once_control or init_routine parameter is NULL.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

193
3rdparty/pthreads4w/manual/pthread_rwlock_init.html vendored
View File

@ -1,193 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_DESTROY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;10211800">
<META NAME="CHANGED" CONTENT="20050505;18563400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_destroy, pthread_rwlock_init - destroy and
initialize a read-write lock object
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>pthread_wrlock_t </B><I>rwlock</I> <B>=
PTHREAD_RWLOCK_INITIALIZER;</B></P>
<P><B>int pthread_rwlock_destroy(pthread_rwlock_t *</B><I>rwlock</I><B>);
<BR>int pthread_rwlock_init(pthread_rwlock_t *restrict</B> <I>rwlock</I><B>,
const pthread_rwlockattr_t *restrict</B> <I>attr</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_destroy</B> function shall destroy the
read-write lock object referenced by <I>rwlock</I> and release any
resources used by the lock. The effect of subsequent use of the lock
is undefined until the lock is reinitialized by another call to
<B>pthread_rwlock_init</B>. An implementation may cause
<B>pthread_rwlock_destroy</B> to set the object referenced by <I>rwlock</I>
to an invalid value. Results are undefined if <B>pthread_rwlock_destroy</B>
is called when any thread holds <I>rwlock</I>. Attempting to destroy
an uninitialized read-write lock results in undefined behavior.
</P>
<P>The <B>pthread_rwlock_init</B> function shall allocate any
resources required to use the read-write lock referenced by <I>rwlock</I>
and initializes the lock to an unlocked state with attributes
referenced by <I>attr</I>. If <I>attr</I> is NULL, the default
read-write lock attributes shall be used; the effect is the same as
passing the address of a default read-write lock attributes object.
Once initialized, the lock can be used any number of times without
being reinitialized. Results are undefined if <B>pthread_rwlock_init</B>
is called specifying an already initialized read-write lock. Results
are undefined if a read-write lock is used without first being
initialized.
</P>
<P>If the <B>pthread_rwlock_init</B> function fails, <I>rwlock</I>
shall not be initialized and the contents of <I>rwlock</I> are
undefined.
</P>
<P><B>Pthreads-w32</B> supports statically initialized <I>rwlock</I>
objects using <B>PTHREAD_RWLOCK_INITIALIZER</B>. <SPAN STYLE="font-weight: medium">
An application should still call <B>pthread_rwlock_destroy</B> at
some point to ensure that any resources consumed by the read/write
lock are released.</SPAN></P>
<P>Only the object referenced by <I>rwlock</I> may be used for
performing synchronization. The result of referring to copies of that
object in calls to <B>pthread_rwlock_destroy</B> ,
<B>pthread_rwlock_rdlock</B> , <B>pthread_rwlock_timedrdlock</B> ,
<B>pthread_rwlock_timedwrlock</B> , <B>pthread_rwlock_tryrdlock</B> ,
<B>pthread_rwlock_trywrlock</B> , <B>pthread_rwlock_unlock</B> , or
<B>pthread_rwlock_wrlock</B> is undefined.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_rwlock_destroy</B> and
<B>pthread_rwlock_init</B> functions shall return zero; otherwise, an
error number shall be returned to indicate the error.
</P>
<P>The [EBUSY] and [EINVAL] error checks, if implemented, act as if
they were performed immediately at the beginning of processing for
the function and caused an error return prior to modifying the state
of the read-write lock specified by <I>rwlock</I>.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_destroy</B> function may fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD>
The implementation has detected an attempt to destroy the object
referenced by <I>rwlock</I> while it is locked.
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>rwlock</I> is invalid.
</DD></DL>
<P>
The <B>pthread_rwlock_init</B> function shall fail if:
</P>
<DL>
<DT><B>EAGAIN</B>
</DT><DD>
The system lacked the necessary resources (other than memory) to
initialize another read-write lock.
</DD><DT>
<B>ENOMEM</B>
</DT><DD>
Insufficient memory exists to initialize the read-write lock.
</DD><DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">
<BR><BR>
</DD></DL>
<P>
The <B>pthread_rwlock_init</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using these and related read-write lock functions may
be subject to priority inversion, as discussed in the Base
Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285,
Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

168
3rdparty/pthreads4w/manual/pthread_rwlock_rdlock.html vendored
View File

@ -1,168 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_RDLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;10352600">
<META NAME="CHANGED" CONTENT="20050505;12554200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_rdlock, pthread_rwlock_tryrdlock - lock a
read-write lock object for reading
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_rwlock_rdlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
<BR></B>i<B>nt pthread_rwlock_tryrdlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_rdlock</B> function shall apply a read lock
to the read-write lock referenced by <I>rwlock</I>. The calling
thread acquires the read lock if a writer does not hold the lock and
there are no writers blocked on the lock.
</P>
<P><B>Pthreads-win32</B> does not prefer either writers or readers in
acquiring the lock – all threads enter a single prioritised FIFO
queue. While this may not be optimally efficient for some
applications, it does ensure that one type does not starve the other.</P>
<P>A thread may hold multiple concurrent read locks on <I>rwlock</I>
(that is, successfully call the <B>pthread_rwlock_rdlock</B> function
<I>n</I> times). If so, the application shall ensure that the thread
performs matching unlocks (that is, it calls the
<A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
function <I>n</I> times).
</P>
<P>The <B>pthread_rwlock_tryrdlock</B> function shall apply a read
lock as in the <B>pthread_rwlock_rdlock</B> function, with the
exception that the function shall fail if the equivalent
<B>pthread_rwlock_rdlock</B> call would have blocked the calling
thread. In no case shall the <B>pthread_rwlock_tryrdlock</B> function
ever block; it always either acquires the lock or fails and returns
immediately.
</P>
<P>Results are undefined if any of these functions are called with an
uninitialized read-write lock.
</P>
<P><B>Pthreads-w32</B> does not detect deadlock if the thread already
owns the lock for writing.</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_rwlock_rdlock</B> function shall
return zero; otherwise, an error number shall be returned to indicate
the error.
</P>
<P>The <B>pthread_rwlock_tryrdlock</B> function shall return zero if
the lock for reading on the read-write lock object referenced by
<I>rwlock</I> is acquired. Otherwise, an error number shall be
returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_tryrdlock</B> function shall fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The read-write lock could not be acquired for reading because a
writer holds the lock or a writer with the appropriate priority was
blocked on it.
</DD></DL>
<P>
The <B>pthread_rwlock_rdlock</B> and <B>pthread_rwlock_tryrdlock</B>
functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD>
The value specified by <I>rwlock</I> does not refer to an
initialized read-write lock object.
</DD><DT>
<B>EAGAIN</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The read lock could not be acquired because the maximum number of
read locks for <I>rwlock</I> has been exceeded.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using these functions may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

156
3rdparty/pthreads4w/manual/pthread_rwlock_timedrdlock.html vendored
View File

@ -1,156 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_TIMEDRDLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;11101700">
<META NAME="CHANGED" CONTENT="20050505;12560000">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_timedrdlock - lock a read-write lock for reading
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; <BR></B>#include &lt;time.h&gt;
</P>
<P><B>int pthread_rwlock_timedrdlock(pthread_rwlock_t *restrict</B>
<I>rwlock</I><B>, const struct timespec *restrict</B> <I>abs_timeout</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_timedrdlock</B> function shall apply a read
lock to the read-write lock referenced by <I>rwlock</I> as in the
<A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
function. However, if the lock cannot be acquired without waiting for
other threads to unlock the lock, this wait shall be terminated when
the specified timeout expires. The timeout shall expire when the
absolute time specified by <I>abs_timeout</I> passes, as measured by
the clock on which timeouts are based (that is, when the value of
that clock equals or exceeds <I>abs_timeout</I>), or if the absolute
time specified by <I>abs_timeout</I> has already been passed at the
time of the call.
</P>
<P>The <B>timespec</B> data type is defined in the <I>&lt;time.h&gt;</I>
header. Under no circumstances shall the function fail with a timeout
if the lock can be acquired immediately. The validity of the
<I>abs_timeout</I> parameter need not be checked if the lock can be
immediately acquired.
</P>
<P>The calling thread may deadlock if at the time the call is made it
holds a write lock on <I>rwlock</I>. The results are undefined if
this function is called with an uninitialized read-write lock.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>The <B>pthread_rwlock_timedrdlock</B> function shall return zero
if the lock for reading on the read-write lock object referenced by
<I>rwlock</I> is acquired. Otherwise, an error number shall be
returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_timedrdlock</B> function shall fail if:
</P>
<DL>
<DT><B>ETIMEDOUT</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The lock could not be acquired before the specified timeout expired.
</DD></DL>
<P>
The <B>pthread_rwlock_timedrdlock</B> function may fail if:
</P>
<DL>
<DT><B>EAGAIN</B>
</DT><DD>
The read lock could not be acquired because the maximum number of
read locks for lock would be exceeded.
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>rwlock</I> does not refer to an
initialized read-write lock object, or the <I>abs_timeout</I>
nanosecond value is less than zero or greater than or equal to 1000
million.
</DD></DL>
<P>
This function shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using this function may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>, <I>&lt;time.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

150
3rdparty/pthreads4w/manual/pthread_rwlock_timedwrlock.html vendored
View File

@ -1,150 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_TIMEDWRLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;11172800">
<META NAME="CHANGED" CONTENT="20050505;12561600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_timedwrlock - lock a read-write lock for writing
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; <BR></B>#include &lt;time.h&gt;
</P>
<P><B>int pthread_rwlock_timedwrlock(pthread_rwlock_t *restrict</B>
<I>rwlock</I><B>, const struct timespec *restrict</B> <I>abs_timeout</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_timedwrlock</B> function shall apply a write
lock to the read-write lock referenced by <I>rwlock</I> as in the
<A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
function. However, if the lock cannot be acquired without waiting for
other threads to unlock the lock, this wait shall be terminated when
the specified timeout expires. The timeout shall expire when the
absolute time specified by <I>abs_timeout</I> passes, as measured by
the clock on which timeouts are based (that is, when the value of
that clock equals or exceeds <I>abs_timeout</I>), or if the absolute
time specified by <I>abs_timeout</I> has already been passed at the
time of the call.
</P>
<P>The <B>timespec</B> data type is defined in the <I>&lt;time.h&gt;</I>
header. Under no circumstances shall the function fail with a timeout
if the lock can be acquired immediately. The validity of the
<I>abs_timeout</I> parameter need not be checked if the lock can be
immediately acquired.
</P>
<P>The calling thread may deadlock if at the time the call is made it
holds the read-write lock. The results are undefined if this function
is called with an uninitialized read-write lock.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>The <B>pthread_rwlock_timedwrlock</B> function shall return zero
if the lock for writing on the read-write lock object referenced by
<I>rwlock</I> is acquired. Otherwise, an error number shall be
returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_timedwrlock</B> function shall fail if:
</P>
<DL>
<DT><B>ETIMEDOUT</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The lock could not be acquired before the specified timeout expired.
</DD></DL>
<P>
The <B>pthread_rwlock_timedwrlock</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by rwlock does not refer to an initialized
read-write lock object, or the <I>abs_timeout</I> nanosecond value
is less than zero or greater than or equal to 1000 million.
</DD></DL>
<P>
This function shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using this function may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>, <I>&lt;time.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

141
3rdparty/pthreads4w/manual/pthread_rwlock_unlock.html vendored
View File

@ -1,141 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_UNLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;11291100">
<META NAME="CHANGED" CONTENT="20050505;12562700">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_unlock - unlock a read-write lock object
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P>in<B>t pthread_rwlock_unlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_unlock</B> function shall release a lock
held on the read-write lock object referenced by <I>rwlock</I>.
Results are undefined if the read-write lock <I>rwlock</I> is not
held by the calling thread.
</P>
<P>If this function is called to release a read lock from the
read-write lock object and there are other read locks currently held
on this read-write lock object, the read-write lock object remains in
the read locked state. If this function releases the last read lock
for this read-write lock object, the read-write lock object shall be
put in the unlocked state with no owners.
</P>
<P>If this function is called to release a write lock for this
read-write lock object, the read-write lock object shall be put in
the unlocked state.
</P>
<P><B>Pthreads-win32</B> does not prefer either writers or readers in
acquiring the lock – all threads enter a single prioritised FIFO
queue. While this may not be optimally efficient for some
applications, it does ensure that one type does not starve the other.</P>
<P>Results are undefined if any of these functions are called with an
uninitialized read-write lock.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_rwlock_unlock</B> function shall
return zero; otherwise, an error number shall be returned to indicate
the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_unlock</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD>
The value specified by <I>rwlock</I> does not refer to an
initialized read-write lock object.
</DD><DD STYLE="margin-left: 0cm; margin-bottom: 0.5cm">
<BR><BR>
</DD></DL>
<P>
The <B>pthread_rwlock_unlock</B> function shall not return an error
code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_trywrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_wrlock.html"><B>pthread_rwlock_wrlock</B>(3)</A>
, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

153
3rdparty/pthreads4w/manual/pthread_rwlock_wrlock.html vendored
View File

@ -1,153 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCK_TRYWRLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;11221900">
<META NAME="CHANGED" CONTENT="20050505;12563800">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlock_trywrlock, pthread_rwlock_wrlock - lock a
read-write lock object for writing
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_rwlock_trywrlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
<BR>int pthread_rwlock_wrlock(pthread_rwlock_t <I>*</I></B><I>rwlock</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlock_trywrlock</B> function shall apply a write
lock like the <B>pthread_rwlock_wrlock</B> function, with the
exception that the function shall fail if any thread currently holds
<I>rwlock</I> (for reading or writing).
</P>
<P>The <B>pthread_rwlock_wrlock</B> function shall apply a write lock
to the read-write lock referenced by <I>rwlock</I>. The calling
thread acquires the write lock if no other thread (reader or writer)
holds the read-write lock <I>rwlock</I>. Otherwise, the thread shall
block until it can acquire the lock. The calling thread may deadlock
if at the time the call is made it holds the read-write lock (whether
a read or write lock).
</P>
<P><B>Pthreads-win32</B> does not prefer either writers or readers in
acquiring the lock – all threads enter a single prioritised FIFO
queue. While this may not be optimally efficient for some
applications, it does ensure that one type does not starve the other.</P>
<P>Results are undefined if any of these functions are called with an
uninitialized read-write lock.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>The <B>pthread_rwlock_trywrlock</B> function shall return zero if
the lock for writing on the read-write lock object referenced by
<I>rwlock</I> is acquired. Otherwise, an error number shall be
returned to indicate the error.
</P>
<P>If successful, the <B>pthread_rwlock_wrlock</B> function shall
return zero; otherwise, an error number shall be returned to indicate
the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlock_trywrlock</B> function shall fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The read-write lock could not be acquired for writing because it was
already locked for reading or writing.
</DD></DL>
<P>
The <B>pthread_rwlock_trywrlock</B> and <B>pthread_rwlock_wrlock</B>
functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>rwlock</I> does not refer to an
initialized read-write lock object.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using these functions may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_rdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedrdlock.html"><B>pthread_rwlock_timedrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_timedwrlock.html"><B>pthread_rwlock_timedwrlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_rdlock.html"><B>pthread_rwlock_tryrdlock</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlock_unlock.html"><B>pthread_rwlock_unlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

141
3rdparty/pthreads4w/manual/pthread_rwlockattr_init.html vendored
View File

@ -1,141 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCKATTR_DESTROY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;504000">
<META NAME="CHANGED" CONTENT="20050505;18474200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlockattr_destroy, pthread_rwlockattr_init - destroy and
initialize the read-write lock attributes object
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_rwlockattr_destroy(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>);
<BR>int pthread_rwlockattr_init(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlockattr_destroy</B> function shall destroy a
read-write lock attributes object. A destroyed <I>attr</I> attributes
object can be reinitialized using <B>pthread_rwlockattr_init</B> ;
the results of otherwise referencing the object after it has been
destroyed are undefined. An implementation may cause
<B>pthread_rwlockattr_destroy</B> to set the object referenced by
<I>attr</I> to an invalid value.
</P>
<P>The <B>pthread_rwlockattr_init</B> function shall initialize a
read-write lock attributes object <I>attr</I> with the default value
for all of the attributes defined by the implementation.
</P>
<P>Results are undefined if <B>pthread_rwlockattr_init</B> is called
specifying an already initialized <I>attr</I> attributes object.
</P>
<P>After a read-write lock attributes object has been used to
initialize one or more read-write locks, any function affecting the
attributes object (including destruction) shall not affect any
previously initialized read-write locks.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_rwlockattr_destroy</B> and
<B>pthread_rwlockattr_init</B> functions shall return zero;
otherwise, an error number shall be returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlockattr_destroy</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
The <B>pthread_rwlockattr_init</B> function shall fail if:
</P>
<DL>
<DT><B>ENOMEM</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
Insufficient memory exists to initialize the read-write lock
attributes object.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_getpshared</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlockattr_setpshared.html"><B>pthread_rwlockattr_setpshared</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

160
3rdparty/pthreads4w/manual/pthread_rwlockattr_setpshared.html vendored
View File

@ -1,160 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_RWLOCKATTR_GETPSHARED&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;10124400">
<META NAME="CHANGED" CONTENT="20050505;12572100">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_rwlockattr_getpshared, pthread_rwlockattr_setpshared - get
and set the process-shared attribute of the read-write lock
attributes object
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_rwlockattr_getpshared(const pthread_rwlockattr_t *
restrict </B><I>attr</I><B>, int *restrict</B> <I>pshared</I><B>);
<BR>int pthread_rwlockattr_setpshared(pthread_rwlockattr_t <I>*</I></B><I>attr</I><B>,
int</B> <I>pshared</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_rwlockattr_getpshared</B> function shall obtain the
value of the <I>process-shared</I> attribute from the initialized
attributes object referenced by <I>attr</I>. The
<B>pthread_rwlockattr_setpshared</B> function shall set the
<I>process-shared</I> attribute in an initialized attributes object
referenced by <I>attr</I>.
</P>
<P>The <I>process-shared</I> attribute shall be set to
<B>PTHREAD_PROCESS_SHARED</B> to permit a read-write lock to be
operated upon by any thread that has access to the memory where the
read-write lock is allocated, even if the read-write lock is
allocated in memory that is shared by multiple processes. If the
<I>process-shared</I> attribute is <B>PTHREAD_PROCESS_PRIVATE</B>,
the read-write lock shall only be operated upon by threads created
within the same process as the thread that initialized the read-write
lock; if threads of differing processes attempt to operate on such a
read-write lock, the behavior is undefined. The default value of the
<I>process-shared</I> attribute shall be <B>PTHREAD_PROCESS_PRIVATE</B>.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines are implemented but
they do not support the process shared option.</P>
<P>Additional attributes, their default values, and the names of the
associated functions to get and set those attribute values are
implementation-defined.
</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_READER_WRITER_LOCKS</B> in
pthread.h as 200112L to indicate that the reader/writer routines are
implemented and may be used.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, the <B>pthread_rwlockattr_getpshared</B>
function shall return zero and store the value of the <I>process-shared</I>
attribute of <I>attr</I> into the object referenced by the <I>pshared</I>
parameter. Otherwise, an error number shall be returned to indicate
the error.
</P>
<P>If successful, the <B>pthread_rwlockattr_setpshared</B> function
shall return zero; otherwise, an error number shall be returned to
indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_rwlockattr_getpshared</B> and
<B>pthread_rwlockattr_setpshared</B> functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>attr</I> is invalid.
</DD></DL>
<P>
The <B>pthread_rwlockattr_setpshared</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the attribute is outside the range of
legal values for that attribute.
</DD><DT>
<B>ENOTSUP</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The new value specified for the attribute is <B>PTHREAD_PROCESS_SHARED</B>.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_rwlock_init.html"><B>pthread_rwlock_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_rwlockattr_init.html"><B>pthread_rwlockattr_init</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

70
3rdparty/pthreads4w/manual/pthread_self.html vendored
View File

@ -1,70 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_SELF(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;11361600">
<META NAME="CHANGED" CONTENT="20050505;11575700">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_self - return identifier of current thread
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>pthread_t pthread_self(void);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_self</B> return the thread identifier for the calling
thread.
</P>
<P><B>Pthreads-w32</B> also provides support for <B>Win32</B> native
threads to interact with POSIX threads through the pthreads API.
Whereas all threads created via a call to pthread_create have a POSIX
thread ID and thread state, the library ensures that any Win32 native
threads that interact through the Pthreads API also generate a POSIX
thread ID and thread state when and if necessary. This provides full
<SPAN LANG="en-GB">reciprocity</SPAN> between Win32 and POSIX
threads. Win32 native threads that generate a POSIX thread ID and
state are treated by the library as having been created with the
<B>PTHREAD_CREATE_DETACHED</B> attribute.</P>
<P>Any Win32 native thread may call <B>pthread_self</B> directly to
return it's POSIX thread identifier. The ID and state will be
generated if it does not already exist. Win32 native threads do not
need to call <B>pthread_self</B> before calling Pthreads-w32 routines
unless that routine requires a pthread_t parameter.</P>
<H2><A HREF="#toc3" NAME="sect3">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc4" NAME="sect4">See Also</A></H2>
<P><A HREF="pthread_equal.html"><B>pthread_equal</B>(3)</A> ,
<A HREF="pthread_join.html"><B>pthread_join</B>(3)</A> ,
<A HREF="pthread_detach.html"><B>pthread_detach</B>(3)</A> ,
<A HREF="pthread_setschedparam.html"><B>pthread_setschedparam</B>(3)</A>
, <A HREF="pthread_setschedparam.html"><B>pthread_getschedparam</B>(3)</A>
.
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Author</A>
</P>
<LI><P><A HREF="#sect4" NAME="toc4">See Also</A>
</P>
</UL>
</BODY>
</HTML>

207
3rdparty/pthreads4w/manual/pthread_setcancelstate.html vendored
View File

@ -1,207 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CANCEL(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;12090500">
<META NAME="CHANGED" CONTENT="20050504;16361300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
pthread_testcancel - thread cancellation
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B>
</P>
<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
*</B><I>oldstate</I><B>);</B>
</P>
<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
*</B><I>oldtype</I><B>);</B>
</P>
<P><B>void pthread_testcancel(void);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Cancellation is the mechanism by which a thread can terminate the
execution of another thread. More precisely, a thread can send a
cancellation request to another thread. Depending on its settings,
the target thread can then either ignore the request, honor it
immediately, or defer it until it reaches a cancellation point.
</P>
<P>When a thread eventually honors a cancellation request, it
performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
at that point: all cleanup handlers are executed in reverse order,
destructor functions for thread-specific data are called, and finally
the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
information.
</P>
<P><B>pthread_cancel</B> sends a cancellation request to the thread
denoted by the <I>thread</I> argument.
</P>
<P><B>pthread_setcancelstate</B> changes the cancellation state for
the calling thread -- that is, whether cancellation requests are
ignored or not. The <I>state</I> argument is the new cancellation
state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
previous cancellation state is stored in the location pointed to by
<I>oldstate</I>, and can thus be restored later by another call to
<B>pthread_setcancelstate</B>.
</P>
<P><B>pthread_setcanceltype</B> changes the type of responses to
cancellation requests for the calling thread: asynchronous
(immediate) or deferred. The <I>type</I> argument is the new
cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
cancel the calling thread as soon as the cancellation request is
received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
request pending until the next cancellation point. If <I>oldtype</I>
is not <B>NULL</B>, the previous cancellation state is stored in the
location pointed to by <I>oldtype</I>, and can thus be restored later
by another call to <B>pthread_setcanceltype</B>.
</P>
<P><B>Pthreads-w32</B> provides two levels of support for
<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
requires an additional DLL and driver be installed on the Windows
system (see the See Also section below) that allows blocked threads
to be cancelled immediately. Partial support means that the target
thread will not cancel until it resumes execution naturally. Partial
support is provided if either the DLL or the driver are not
automatically detected by the pthreads-w32 library at run-time.</P>
<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
with cancellation enabled and deferred. That is, the initial
cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
type is <B>PTHREAD_CANCEL_DEFERRED</B>.
</P>
<P>Cancellation points are those points in the program execution
where a test for pending cancellation requests is performed and
cancellation is executed if positive. The following POSIX threads
functions are cancellation points:
</P>
<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
<BR><A HREF="pthread_cond_wait.html"><B>pthread_cond_wait</B>(3)</A>
<BR><A HREF="pthread_cond_timedwait.html"><B>pthread_cond_timedwait</B>(3)</A>
<BR><A HREF="pthread_testcancel.html"><B>pthread_testcancel</B>(3)</A>
<BR><A HREF="sem_wait.html"><B>sem_wait</B>(3)</A> <BR><A HREF="sem_timedwait.html"><B>sem_timedwait</B>(3)</A>
<BR><A HREF="sigwait.html"><B>sigwait</B>(3)</A> (not supported under
<B>Pthreads-w32</B>)</P>
<P><B>Pthreads-w32</B> provides two functions to enable additional
cancellation points to be created in user functions that block on
Win32 HANDLEs:</P>
<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
<P>All other POSIX threads functions are guaranteed not to be
cancellation points. That is, they never perform cancellation in
deferred cancellation mode.
</P>
<P><B>pthread_testcancel</B> does nothing except testing for pending
cancellation and executing it. Its purpose is to introduce explicit
checks for cancellation in long sequences of code that do not call
cancellation point functions otherwise.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
code on error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P><B>pthread_cancel</B> returns the following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
no thread could be found corresponding to that specified by the
<I>thread</I> ID.
</DD></DL>
</DL>
<P>
<B>pthread_setcancelstate</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>state</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B>
</BLOCKQUOTE>
<P><B>pthread_setcanceltype</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>type</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
</BLOCKQUOTE>
<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
, Pthreads-w32 package README file 'Prerequisites' section.
</P>
<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
<P>POSIX specifies that a number of system calls (basically, all
system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
, etc.) and library functions that may call these system calls (e.g.
<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
points. <B>Pthreads-win32</B> is not integrated enough with the C
library to implement this, and thus none of the C library functions
is a cancellation point.
</P>
<P>A workaround for these calls is to temporarily switch to
asynchronous cancellation (assuming full asynchronous cancellation
support is installed). So, checking for cancellation during a <B>read</B>
system call, for instance, can be achieved as follows:
</P>
<BLOCKQUOTE><BR><BR>
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
read(fd, buffer, length);
pthread_setcanceltype(oldCancelType, NULL);</PRE>
<HR>
<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

207
3rdparty/pthreads4w/manual/pthread_setcanceltype.html vendored
View File

@ -1,207 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_CANCEL(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050504;12090500">
<META NAME="CHANGED" CONTENT="20050504;16362800">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_cancel, pthread_setcancelstate, pthread_setcanceltype,
pthread_testcancel - thread cancellation
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_cancel(pthread_t </B><I>thread</I><B>);</B>
</P>
<P><B>int pthread_setcancelstate(int </B><I>state</I><B>, int
*</B><I>oldstate</I><B>);</B>
</P>
<P><B>int pthread_setcanceltype(int </B><I>type</I><B>, int
*</B><I>oldtype</I><B>);</B>
</P>
<P><B>void pthread_testcancel(void);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Cancellation is the mechanism by which a thread can terminate the
execution of another thread. More precisely, a thread can send a
cancellation request to another thread. Depending on its settings,
the target thread can then either ignore the request, honor it
immediately, or defer it until it reaches a cancellation point.
</P>
<P>When a thread eventually honors a cancellation request, it
performs as if <B>pthread_exit(PTHREAD_CANCELED)</B> has been called
at that point: all cleanup handlers are executed in reverse order,
destructor functions for thread-specific data are called, and finally
the thread stops executing with the return value <B>PTHREAD_CANCELED</B>.
See <A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> for more
information.
</P>
<P><B>pthread_cancel</B> sends a cancellation request to the thread
denoted by the <I>thread</I> argument.
</P>
<P><B>pthread_setcancelstate</B> changes the cancellation state for
the calling thread -- that is, whether cancellation requests are
ignored or not. The <I>state</I> argument is the new cancellation
state: either <B>PTHREAD_CANCEL_ENABLE</B> to enable cancellation, or
<B>PTHREAD_CANCEL_DISABLE</B> to disable cancellation (cancellation
requests are ignored). If <I>oldstate</I> is not <B>NULL</B>, the
previous cancellation state is stored in the location pointed to by
<I>oldstate</I>, and can thus be restored later by another call to
<B>pthread_setcancelstate</B>.
</P>
<P><B>pthread_setcanceltype</B> changes the type of responses to
cancellation requests for the calling thread: asynchronous
(immediate) or deferred. The <I>type</I> argument is the new
cancellation type: either <B>PTHREAD_CANCEL_ASYNCHRONOUS</B> to
cancel the calling thread as soon as the cancellation request is
received, or <B>PTHREAD_CANCEL_DEFERRED</B> to keep the cancellation
request pending until the next cancellation point. If <I>oldtype</I>
is not <B>NULL</B>, the previous cancellation state is stored in the
location pointed to by <I>oldtype</I>, and can thus be restored later
by another call to <B>pthread_setcanceltype</B>.
</P>
<P><B>Pthreads-w32</B> provides two levels of support for
<B>PTHREAD_CANCEL_ASYNCHRONOUS</B>: full and partial. Full support
requires an additional DLL and driver be installed on the Windows
system (see the See Also section below) that allows blocked threads
to be cancelled immediately. Partial support means that the target
thread will not cancel until it resumes execution naturally. Partial
support is provided if either the DLL or the driver are not
automatically detected by the pthreads-w32 library at run-time.</P>
<P>Threads are always created by <A HREF="pthread_create.html"><B>pthread_create</B>(3)</A>
with cancellation enabled and deferred. That is, the initial
cancellation state is <B>PTHREAD_CANCEL_ENABLE</B> and the initial
type is <B>PTHREAD_CANCEL_DEFERRED</B>.
</P>
<P>Cancellation points are those points in the program execution
where a test for pending cancellation requests is performed and
cancellation is executed if positive. The following POSIX threads
functions are cancellation points:
</P>
<P><A HREF="pthread_join.html"><B>pthread_join</B>(3)</A>
<BR><A HREF="pthread_cond_wait.html"><B>pthread_cond_wait</B>(3)</A>
<BR><A HREF="pthread_cond_timedwait.html"><B>pthread_cond_timedwait</B>(3)</A>
<BR><A HREF="pthread_testcancel.html"><B>pthread_testcancel</B>(3)</A>
<BR><A HREF="sem_wait.html"><B>sem_wait</B>(3)</A> <BR><A HREF="sem_timedwait.html"><B>sem_timedwait</B>(3)</A>
<BR><A HREF="sigwait.html"><B>sigwait</B>(3)</A> (not supported under
<B>Pthreads-w32</B>)</P>
<P><B>Pthreads-w32</B> provides two functions to enable additional
cancellation points to be created in user functions that block on
Win32 HANDLEs:</P>
<P><A HREF="pthreadCancelableWait.html">pthreadCancelableWait()</A>
<BR><A HREF="pthreadCancelableTimedWait.html">pthreadCancelableTimedWait()</A></P>
<P>All other POSIX threads functions are guaranteed not to be
cancellation points. That is, they never perform cancellation in
deferred cancellation mode.
</P>
<P><B>pthread_testcancel</B> does nothing except testing for pending
cancellation and executing it. Its purpose is to introduce explicit
checks for cancellation in long sequences of code that do not call
cancellation point functions otherwise.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><B>pthread_cancel</B>, <B>pthread_setcancelstate</B> and
<B>pthread_setcanceltype</B> return 0 on success and a non-zero error
code on error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P><B>pthread_cancel</B> returns the following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
no thread could be found corresponding to that specified by the
<I>thread</I> ID.
</DD></DL>
</DL>
<P>
<B>pthread_setcancelstate</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>state</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_ENABLE</B> nor <B>PTHREAD_CANCEL_DISABLE</B>
</BLOCKQUOTE>
<P><B>pthread_setcanceltype</B> returns the following error code on
error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>type</I> argument is not
</DD></DL>
</DL>
<BLOCKQUOTE>
<B>PTHREAD_CANCEL_DEFERRED</B> nor <B>PTHREAD_CANCEL_ASYNCHRONOUS</B>
</BLOCKQUOTE>
<H2><A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="pthread_exit.html"><B>pthread_exit</B>(3)</A> ,
<A HREF="pthread_cleanup_push.html"><B>pthread_cleanup_push</B>(3)</A>
, <A HREF="pthread_cleanup_pop.html"><B>pthread_cleanup_pop</B>(3)</A>
, Pthreads-w32 package README file 'Prerequisites' section.
</P>
<H2><A HREF="#toc7" NAME="sect7">Bugs</A></H2>
<P>POSIX specifies that a number of system calls (basically, all
system calls that may block, such as <A HREF="read.html"><B>read</B>(2)</A>
, <A HREF="write.html"><B>write</B>(2)</A> , <A HREF="wait.html"><B>wait</B>(2)</A>
, etc.) and library functions that may call these system calls (e.g.
<A HREF="fprintf.html"><B>fprintf</B>(3)</A> ) are cancellation
points. <B>Pthreads-win32</B> is not integrated enough with the C
library to implement this, and thus none of the C library functions
is a cancellation point.
</P>
<P>A workaround for these calls is to temporarily switch to
asynchronous cancellation (assuming full asynchronous cancellation
support is installed). So, checking for cancellation during a <B>read</B>
system call, for instance, can be achieved as follows:
</P>
<BLOCKQUOTE><BR><BR>
</BLOCKQUOTE>
<PRE STYLE="margin-left: 1cm; margin-right: 1cm">pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &amp;oldCancelType);
read(fd, buffer, length);
pthread_setcanceltype(oldCancelType, NULL);</PRE>
<HR>
<BLOCKQUOTE><A NAME="toc"></A><B>Table of Contents</B></BLOCKQUOTE>
<UL>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">See
Also</A>
</BLOCKQUOTE>
<LI><BLOCKQUOTE><A HREF="#sect7" NAME="toc7">Bugs</A>
</BLOCKQUOTE>
</UL>
</BODY>
</HTML>

155
3rdparty/pthreads4w/manual/pthread_setconcurrency.html vendored
View File

@ -1,155 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_GETCONCURRENCY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;19162600">
<META NAME="CHANGED" CONTENT="20050505;19223800">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_getconcurrency, pthread_setconcurrency - get and set the
level of concurrency
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_getconcurrency(void);</B> <BR><B>int
pthread_setconcurrency(int</B> <I>new_level</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Unbound threads in a process may or may not be required to be
simultaneously active. By default, the threads implementation ensures
that a sufficient number of threads are active so that the process
can continue to make progress. While this conserves system resources,
it may not produce the most effective level of concurrency.
</P>
<P>The <B>pthread_setconcurrency</B> function allows an application
to inform the threads implementation of its desired concurrency
level, <I>new_level</I>. The actual level of concurrency provided by
the implementation as a result of this function call is unspecified.
</P>
<P>If <I>new_level</I> is zero, it causes the implementation to
maintain the concurrency level at its discretion as if
<B>pthread_setconcurrency</B> had never been called.
</P>
<P>The <B>pthread_getconcurrency</B> function shall return the value
set by a previous call to the <B>pthread_setconcurrency</B> function.
If the <B>pthread_setconcurrency</B> function was not previously
called, this function shall return zero to indicate that the
implementation is maintaining the concurrency level.
</P>
<P>A call to <B>pthread_setconcurrency</B> shall inform the
implementation of its desired concurrency level. The implementation
shall use this as a hint, not a requirement.
</P>
<P>If an implementation does not support multiplexing of user threads
on top of several kernel-scheduled entities, the
<B>pthread_setconcurrency</B> and <B>pthread_getconcurrency</B>
functions are provided for source code compatibility but they shall
have no effect when called. To maintain the function semantics, the
<I>new_level</I> parameter is saved when <B>pthread_setconcurrency</B>
is called so that a subsequent call to <B>pthread_getconcurrency</B>
shall return the same value.
</P>
<P><B>Pthreads-w32</B> provides these routines for source code
compatibility only, as described in the previous paragraph.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>pthread_setconcurrency</B> function shall
return zero; otherwise, an error number shall be returned to indicate
the error.
</P>
<P>The <B>pthread_getconcurrency</B> function shall always return the
concurrency level set by a previous call to <B>pthread_setconcurrency</B>
. If the <B>pthread_setconcurrency</B> function has never been
called, <B>pthread_getconcurrency</B> shall return zero.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_setconcurrency</B> function shall fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD>
The value specified by <I>new_level</I> is negative.
</DD><DT>
<B>EAGAIN</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specific by <I>new_level</I> would cause a system resource
to be exceeded.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Use of these functions changes the state of the underlying
concurrency upon which the application depends. Library developers
are advised to not use the <B>pthread_getconcurrency</B> and
<B>pthread_setconcurrency</B> functions since their use may conflict
with an applications use of these functions.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P>The Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

114
3rdparty/pthreads4w/manual/pthread_setschedparam.html vendored
View File

@ -1,114 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_SETSCHEDPARAM(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 2.4 (Linux)">
<META NAME="CREATED" CONTENT="20050504;18110100">
<META NAME="CHANGEDBY" CONTENT="Ross Johnson">
<META NAME="CHANGED" CONTENT="20080630;22330400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_setschedparam, pthread_getschedparam - control thread
scheduling
</P>
<P>parameters
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>int pthread_setschedparam(pthread_t </B><I>target_thread</I><B>,
int </B><I>policy</I><B>, const struct sched_param *</B><I>param</I><B>);</B>
</P>
<P><B>int pthread_getschedparam(pthread_t </B><I>target_thread</I><B>,
int *</B><I>policy</I><B>, struct sched_param *</B><I>param</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_setschedparam</B> sets the scheduling parameters for
the thread <I>target_thread</I> as indicated by <I>policy</I> and
<I>param</I>. <I>policy</I> can be either <B>SCHED_OTHER</B>
(regular, non-real-time scheduling), <B>SCHED_RR</B> (real-time,
round-robin) or <B>SCHED_FIFO</B> (real-time, first-in first-out).
<I>param</I> specifies the scheduling priority for the two real-time
policies.</P>
<P><B>Pthreads-w32</B> only supports SCHED_OTHER and does not support
the real-time scheduling policies <B>SCHED_RR</B> and <B>SCHED_FIFO.</B>
</P>
<P><B>pthread_getschedparam</B> retrieves the scheduling policy and
scheduling parameters for the thread <I>target_thread</I> and stores
them in the locations pointed to by <I>policy</I> and <I>param</I>,
respectively.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P><B>pthread_setschedparam</B> and <B>pthread_getschedparam</B>
return 0 on success and a non-zero error code on error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>On error, <B>pthread_setschedparam</B> returns the following error
codes:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ENOTSUP</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>policy</I> is not <B>SCHED_OTHER.</B></DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
One of the arguments is invalid, or the priority value specified by
<I>param</I> is not valid for the specified policy.</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
The <I>target_thread</I> is invalid or has already terminated
</DD></DL>
</DL>
<P>
On error, <B>pthread_getschedparam</B> returns the following error
codes:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ESRCH</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
the <I>target_thread</I> is invalid or has already terminated
</DD></DL>
</DL>
<H2>
<A HREF="#toc5" NAME="sect5">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc6" NAME="sect6">See Also</A></H2>
<P><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(2)</A>
, <A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(2)</A>
, <A HREF="sched_getparam.html"><B>sched_getparam</B>(2)</A> ,
<A HREF="pthread_attr_init.html"><B>pthread_attr_setschedpolicy</B>(3)</A>
, <A HREF="pthread_attr_init.html"><B>pthread_attr_setschedparam</B>(3)</A>
.
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Author</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">See Also</A>
</P>
</UL>
</BODY>
</HTML>

176
3rdparty/pthreads4w/manual/pthread_spin_init.html vendored
View File

@ -1,176 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_SPIN_DESTROY&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;12074100">
<META NAME="CHANGED" CONTENT="20050505;19014200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_spin_destroy, pthread_spin_init - destroy or initialize a
spin lock object (<B>ADVANCED REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>pthread_spinlock_t</B> <I>lock</I> <B>=
PTHREAD_SPINLOCK_INITIALIZER;</B></P>
<P><B>int pthread_spin_destroy(pthread_spinlock_t *</B><I>lock</I><B>);
<BR>int pthread_spin_init(pthread_spinlock_t *</B><I>lock</I><B>, int</B>
<I>pshared</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_spin_destroy</B> function shall destroy the spin
lock referenced by <I>lock</I> and release any resources used by the
lock. The effect of subsequent use of the lock is undefined until the
lock is reinitialized by another call to <B>pthread_spin_init</B> .
The results are undefined if <B>pthread_spin_destroy</B> is called
when a thread holds the lock, or if this function is called with an
uninitialized thread spin lock.
</P>
<P>The <B>pthread_spin_init</B> function shall allocate any resources
required to use the spin lock referenced by <I>lock</I> and
initialize the lock to an unlocked state.
</P>
<P><B>Pthreads-w32</B> supports single and multiple processor systems
as well as process CPU affinity masking by checking the mask when the
spin lock is initialized. If the process is using only a single
processor at the time <B>pthread_spin_init</B> is called then the
spin lock is initialized as a PTHREAD_MUTEX_NORMAL mutex object. A
thread that calls <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock(3)</B></A>
will block rather than spin in this case. If the process CPU affinity
mask is altered after the spin lock has been initialised, the spin
lock is not modified, and may no longer be optimal for the number of
CPUs available.</P>
<P><B>Pthreads-w32</B> defines <B>_POSIX_THREAD_PROCESS_SHARED</B> in
pthread.h as -1 to indicate that these routines do not support the
<B>PTHREAD_PROCESS_SHARED</B> attribute. <B>pthread_spin_init</B>
will return the error <B>ENOTSUP</B> if the value of <I>pshared</I>
is not <B>PTHREAD_PROCESS_PRIVATE</B>.</P>
<P>The results are undefined if <B>pthread_spin_init</B> is called
specifying an already initialized spin lock. The results are
undefined if a spin lock is used without first being initialized.
</P>
<P>If the <B>pthread_spin_init</B> function fails, the lock is not
initialized and the contents of <I>lock</I> are undefined.
</P>
<P>Only the object referenced by <I>lock</I> may be used for
performing synchronization.
</P>
<P>The result of referring to copies of that object in calls to
<B>pthread_spin_destroy</B> , <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
, <A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B>(3)</A>,
or <A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
is undefined.
</P>
<P><B>Pthreads-w32</B> supports statically initialized spin locks
using <B>PTHREAD_SPINLOCK_INITIALIZER</B>. An application should
still call <B>pthread_spin_destroy</B> at some point to ensure that
any resources consumed by the spin lock are released.</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, these functions shall return zero;
otherwise, an error number shall be returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>These functions may fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD>
The implementation has detected an attempt to initialize or destroy
a spin lock while it is in use (for example, while being used in a
<A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
call) by another thread.
</DD><DT>
<B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>lock</I> is invalid.
</DD></DL>
<P>
The <B>pthread_spin_init</B> function shall fail if:
</P>
<DL>
<DT><B>ENOTSUP</B>
</DT><DD>
The value of <I>pshared</I> is not <B>PTHREAD_PROCESS_PRIVATE</B>.</DD><DT>
<B>ENOMEM</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
Insufficient memory exists to initialize the lock.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>The <B>pthread_spin_destroy</B> and <B>pthread_spin_init</B>
functions are part of the Spin Locks option and need not be provided
on all implementations.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A> <B>,</B>
<A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

141
3rdparty/pthreads4w/manual/pthread_spin_lock.html vendored
View File

@ -1,141 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_SPIN_LOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;12202300">
<META NAME="CHANGED" CONTENT="20050505;19302300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_spin_lock, pthread_spin_trylock - lock a spin lock object
(<B>ADVANCED REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_spin_lock(pthread_spinlock_t *</B><I>lock</I><B>);
<BR>int pthread_spin_trylock(pthread_spinlock_t *</B><I>lock</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_spin_lock</B> function shall lock the spin lock
referenced by <I>lock</I>. The calling thread shall acquire the lock
if it is not held by another thread. Otherwise, the thread shall spin
(that is, shall not return from the <B>pthread_spin_lock</B> call)
until the lock becomes available. The results are undefined if the
calling thread holds the lock at the time the call is made.</P>
<P><B>Pthreads-w32</B> supports single and multiple processor systems
as well as process CPU affinity masking by checking the mask when the
spin lock is initialized. If the process is using only a single
processor at the time <A HREF="pthread_spin_init.html"><B>pthread_spin_init</B>(3)</A>
is called then the spin lock is initialized as a PTHREAD_MUTEX_NORMAL
mutex object. A thread that calls <B>pthread_spin_lock</B> will block
rather than spin in this case. If the process CPU affinity mask is
altered after the spin lock has been initialised, the spin lock is
not modified, and may no longer be optimal for the number of CPUs
available.</P>
<P>The <B>pthread_spin_trylock</B> function shall lock the spin lock
referenced by <I>lock</I> if it is not held by any thread. Otherwise,
the function shall fail.
</P>
<P>The results are undefined if any of these functions is called with
an uninitialized spin lock.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, these functions shall return zero;
otherwise, an error number shall be returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>These functions may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value specified by <I>lock</I> does not refer to an initialized
spin lock object.
</DD></DL>
<P>
The <B>pthread_spin_trylock</B> function shall fail if:
</P>
<DL>
<DT><B>EBUSY</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
A thread currently holds the lock.
</DD></DL>
<P>
These functions shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>Applications using this function may be subject to priority
inversion, as discussed in the Base Definitions volume of
IEEE&nbsp;Std&nbsp;1003.1-2001, Section 3.285, Priority Inversion.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_spin_unlock.html"><B>pthread_spin_unlock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

124
3rdparty/pthreads4w/manual/pthread_spin_unlock.html vendored
View File

@ -1,124 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;PTHREAD_SPIN_UNLOCK&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;12401400">
<META NAME="CHANGED" CONTENT="20050505;12462400">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>pthread_spin_unlock - unlock a spin lock object (<B>ADVANCED
REALTIME THREADS</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt; </B>
</P>
<P><B>int pthread_spin_unlock(pthread_spinlock_t *</B><I>lock</I><B>);
</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>pthread_spin_unlock</B> function shall release the spin
lock referenced by <I>lock</I> which was locked via the
<A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A> or
<A HREF="pthread_spin_lock.html"><B>pthread_spin_trylock</B>(3)</A>
functions. If there are threads spinning on the lock when
<B>pthread_spin_unlock</B> is called, the lock becomes available and
an unspecified spinning thread shall acquire the lock.
</P>
<P><B>Pthreads-w32</B> does not check ownership of the lock and it is
therefore possible for a thread other than the locker to unlock the
spin lock. This is not a feature that should be exploited.</P>
<P>The results are undefined if this function is called with an
uninitialized thread spin lock.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, the <B>pthread_spin_unlock</B>
function shall return zero; otherwise, an error number shall be
returned to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>pthread_spin_unlock</B> function may fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD>
An invalid argument was specified.
</DD><DD STYLE="margin-left: -2cm">
<BR>
</DD></DL>
<P>
This function shall not return an error code of [EINTR].
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P><B>Pthreads-w32</B> does not check ownership of the lock and it is
therefore possible for a thread other than the locker to unlock the
spin lock. This is not a feature that should be exploited.</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="pthread_spin_init.html"><B>pthread_spin_destroy</B>(3)</A>
<B>,</B> <A HREF="pthread_spin_lock.html"><B>pthread_spin_lock</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;pthread.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

76
3rdparty/pthreads4w/manual/pthread_timechange_handler_np.html vendored
View File

@ -1,76 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_TIMECHANGE_HANDLER_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;22110600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_timechange_handler_np –
alert timed waiting condition variables to system time changes.</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>void * pthread_timechange_handler_np(void * </B><I>dummy</I><B>);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>To improve tolerance against operator or time service initiated
system clock changes.</P>
<P><B>pthread_timechange_handler_np </B>can be called by an
application when it receives a WM_TIMECHANGE message from the system.
At present it broadcasts all condition variables so that waiting
threads can wake up and re-evaluate their conditions and restart
their timed waits if required.</P>
<P><B>pthread_timechange_handler_np </B>has the same return type and
argument type as a thread routine so that it may be called directly
through pthread_create(), i.e. as a separate thread. If run as a
thread, the return code must be retrieved through <A HREF="pthread_join.html"><B>pthread_join</B>()</A>.</P>
<P>Although the <I>dummy</I> parameter is required it is not used and
any value including NULL can be given.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
<P><B>pthread_timechange_handler_np</B> returns 0 on success, or an
error code.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>The <B>pthread_timechange_handler_np</B> function returns the
following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B>
</DT></DL>
</DL>
<P STYLE="margin-left: 2cm; margin-bottom: 0cm">
To indicate that not all condition variables were signalled for some
reason.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

74
3rdparty/pthreads4w/manual/pthread_win32_attach_detach_np.html vendored
View File

@ -1,74 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_WIN32_ATTACH_DETACH_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050505;22415600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_win32_process_attach_np,
pthread_win32_process_detach_np, pthread_win32_thread_attach_np,
pthread_win32_thread_detach_np – exposed versions of the
pthreads-w32 DLL dllMain() switch functionality for use when
statically linking the library.</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>BOOL pthread_win32_process_attach_np (void);</B></P>
<P><B>BOOL pthread_win32_process_detach_np (void);</B></P>
<P><B>BOOL pthread_win32_thread_attach_np (void);</B></P>
<P><B>BOOL pthread_win32_thread_detach_np (void);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>These functions contain the code normally run via <b>dllMain</b>
when the library is used as a dll but which need to be called
explicitly by an application when the library is statically linked. As of version 2.9.0, the static library built using either MSC or GCC includes RT hooks which will call the pthread_win32_process_*_np routines automatically on start/exit of the application.</P>
<P>You will need to call <B>pthread_win32_process_attach_np</B>
before you can call any pthread routines when statically linking. You
should call <B>pthread_win32_process_detach_np</B> before exiting
your application to clean up.</P>
<P><B>pthread_win32_thread_attach_np</B> is currently a no-op, but
<B>pthread_win32_thread_detach_np</B> is needed to clean up the
implicit pthread handle that is allocated to a Win32 thread if it
calls certain pthreads routines. Call this routine when the Win32
thread exits.</P>
<P>These functions invariably return TRUE except for
<B>pthread_win32_process_attach_np</B> which will return FALSE if
pthreads-w32 initialisation fails.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
<P>These routines return TRUE (non-zero) on success, or FALSE (0) if
they fail.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>None.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

68
3rdparty/pthreads4w/manual/pthread_win32_test_features_np.html vendored
View File

@ -1,68 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>PTHREAD_WIN32_TEST_FEATURES_NP manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;322600">
<META NAME="CHANGED" CONTENT="20050510;17405600">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P STYLE="font-weight: medium">pthread_win32_test_features_np –
find out what features were detected at process attach time.</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;pthread.h&gt;</B>
</P>
<P><B>BOOL pthread_win32_test_features_np(int</B> <I>mask</I><B>);</B></P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P><B>pthread_win32_test_features_np</B> allows an application to
check which run-time auto-detected features are available within the
library.</P>
<P>The possible features are:</P>
<P><B>PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE</B></P>
<P STYLE="margin-left: 2cm">Return TRUE if the Win32 version of
InterlockedCompareExchange() is being used. On IA32 systems the
library can use optimised and inlinable assembler versions of
InterlockedExchange() and InterlockedCompareExchange().</P>
<P><B>PTW32_ALERTABLE_ASYNC_CANCEL</B></P>
<P STYLE="margin-left: 2cm">Return TRUE if the QueueUserAPCEx package
QUSEREX.DLL and the AlertDrv.sys driver was detected. This package
provides alertable (pre-emptive) asynchronous threads cancellation.
If this feature returns FALSE then the default async cancel scheme is
in use, which cannot cancel blocked threads.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P>None.</P>
<H2><A HREF="#toc4" NAME="sect4"><FONT COLOR="#000080">Return Value</FONT></A></H2>
<P><B>pthread_win32_test_features_np</B> returns TRUE (non-zero) if
the specified feature is present, and FALSE (0) otherwise.</P>
<H2><A HREF="#toc5" NAME="sect5">Errors</A></H2>
<P>None.</P>
<H2><A HREF="#toc6" NAME="sect6">Author</A></H2>
<P>Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Errors</A>
</P>
<LI><P><A HREF="#sect6" NAME="toc6">Author</A>
</P>
</UL>
</BODY>
</HTML>

115
3rdparty/pthreads4w/manual/sched_get_priority_max.html vendored
View File

@ -1,115 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;SCHED_GET_PRIORITY_MAX&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;12575100">
<META NAME="CHANGED" CONTENT="20050510;12533300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>sched_get_priority_max, sched_get_priority_min - get priority
limits (<B>REALTIME</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;sched.h&gt; </B>
</P>
<P><B>int sched_get_priority_max(int</B> <I>policy</I><B>); <BR>int
sched_get_priority_min(int</B> <I>policy</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>sched_get_priority_max</B> and <B>sched_get_priority_min</B>
functions shall return the appropriate maximum or minimum,
respectively, for the scheduling policy specified by <I>policy</I>.
</P>
<P>The value of <I>policy</I> shall be one of the scheduling policy
values defined in <I>&lt;sched.h&gt;</I>.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>If successful, the <B>sched_get_priority_max</B> and
<B>sched_get_priority_min</B> functions shall return the appropriate
maximum or minimum values, respectively. If unsuccessful, they shall
return a value of -1 and set <I>errno</I> to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>sched_get_priority_max</B> and <B>sched_get_priority_min</B>
functions shall fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
The value of the <I>policy</I> parameter does not represent a
defined scheduling policy.
</DD></DL>
<P>
<I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(3)</A>
<B>,</B> <A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;sched.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

127
3rdparty/pthreads4w/manual/sched_getscheduler.html vendored
View File

@ -1,127 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;SCHED_GETSCHEDULER&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;13153500">
<META NAME="CHANGED" CONTENT="20050505;13202000">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>sched_getscheduler - get scheduling policy (<B>REALTIME</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;sched.h&gt; </B>
</P>
<P><B>int sched_getscheduler(pid_t</B> <I>pid</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>sched_getscheduler</B> function shall return the scheduling
policy of the process specified by <I>pid</I>. If the value of <I>pid</I>
is negative, the behavior of the <B>sched_getscheduler</B> function
is unspecified.
</P>
<P>The values that can be returned by <B>sched_getscheduler</B> are
defined in the <I>&lt;sched.h&gt;</I> header.
</P>
<P><B>Pthreads-w32</B> only supports the <B>SCHED_OTHER</B> policy,
which is the only value that can be returned. However, checks on <I>pid</I>
and permissions are performed first so that the other useful side
effects of this routine are retained.</P>
<P>If a process specified by <I>pid</I> exists, and if the calling
process has permission, the scheduling policy shall be returned for
the process whose process ID is equal to <I>pid</I>.
</P>
<P>If <I>pid</I> is zero, the scheduling policy shall be returned for
the calling process.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, the <B>sched_getscheduler</B> function
shall return the scheduling policy of the specified process. If
unsuccessful, the function shall return -1 and set <I>errno</I> to
indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>sched_getscheduler</B> function shall fail if:
</P>
<DL>
<DT><B>EPERM</B>
</DT><DD>
The requesting process does not have permission to determine the
scheduling policy of the specified process.
</DD><DT>
<B>ESRCH</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
No process can be found corresponding to that specified by <I>pid</I>.
</DD></DL>
<P>
<I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="sched_setscheduler.html"><B>sched_setscheduler</B>(3)</A>
, the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;sched.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

181
3rdparty/pthreads4w/manual/sched_setscheduler.html vendored
View File

@ -1,181 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;SCHED_SETSCHEDULER&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;13012200">
<META NAME="CHANGED" CONTENT="20050505;13193700">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>sched_setscheduler - set scheduling policy and parameters
(<B>REALTIME</B>)
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;sched.h&gt; </B>
</P>
<P><B>int sched_setscheduler(pid_t</B> <I>pid</I><B>, int</B> <I>policy</I><B>,
const struct sched_param *</B><I>param</I><B>); </B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>sched_setscheduler</B> function shall set the scheduling
policy and scheduling parameters of the process specified by <I>pid</I>
to <I>policy</I> and the parameters specified in the <B>sched_param</B>
structure pointed to by <I>param</I>, respectively. The value of the
<I>sched_priority</I> member in the <B>sched_param</B> structure
shall be any integer within the inclusive priority range for the
scheduling policy specified by <I>policy</I>. If the value of <I>pid</I>
is negative, the behavior of the <B>sched_setscheduler</B> function
is unspecified.
</P>
<P>The possible values for the <I>policy</I> parameter are defined in
the <I>&lt;sched.h&gt;</I> header.
</P>
<P><B>Pthreads-w32</B> only supports the <B>SCHED_OTHER</B> policy.
Any other value for <I>policy</I> will return failure with errno set
to <B>ENOSYS</B>. However, checks on <I>pid</I> and permissions are
performed first so that the other useful side effects of this routine
are retained.</P>
<P>If a process specified by <I>pid</I> exists, and if the calling
process has permission, the scheduling policy and scheduling
parameters shall be set for the process whose process ID is equal to
<I>pid</I>.
</P>
<P>If <I>pid</I> is zero, the scheduling policy and scheduling
parameters shall be set for the calling process.
</P>
<P>Implementations may require that the requesting process have
permission to set its own scheduling parameters or those of another
process. Additionally, implementation-defined restrictions may apply
as to the appropriate privileges required to set a process’ own
scheduling policy, or another process’ scheduling policy, to a
particular value.
</P>
<P>The <B>sched_setscheduler</B> function shall be considered
successful if it succeeds in setting the scheduling policy and
scheduling parameters of the process specified by <I>pid</I> to the
values specified by <I>policy</I> and the structure pointed to by
<I>param</I>, respectively.
</P>
<P>The effect of this function on individual threads is dependent on
the scheduling contention scope of the threads:
</P>
<DL>
<DT>*
</DT><DD STYLE="margin-bottom: 0.5cm">
For threads with system scheduling contention scope, these functions
shall have no effect on their scheduling.
</DD><DT>
*
</DT><DD STYLE="margin-bottom: 0.5cm">
For threads with process scheduling contention scope, the threads’
scheduling policy and associated parameters shall not be affected.
However, the scheduling of these threads with respect to threads in
other processes may be dependent on the scheduling parameters of
their process, which are governed using these functions.
</DD></DL>
<P>
This function is not atomic with respect to other threads in the
process. Threads may continue to execute while this function call is
in the process of changing the scheduling policy and associated
scheduling parameters for the underlying kernel-scheduled entities
used by the process contention scope threads.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>Upon successful completion, the function shall return the former
scheduling policy of the specified process. If the <B>sched_setscheduler</B>
function fails to complete successfully, the policy and scheduling
parameters shall remain unchanged, and the function shall return a
value of -1 and set <I>errno</I> to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>The <B>sched_setscheduler</B> function shall fail if:
</P>
<DL>
<DT><B>EINVAL</B>
</DT><DD>
The value of the <I>policy</I> parameter is invalid, or one or more
of the parameters contained in <I>param</I> is outside the valid
range for the specified scheduling policy.
</DD><DT>
<B>EPERM</B>
</DT><DD>
The requesting process does not have permission to set either or
both of the scheduling parameters or the scheduling policy of the
specified process.
</DD><DT>
<B>ESRCH</B>
</DT><DD STYLE="margin-bottom: 0.5cm">
No process can be found corresponding to that specified by <I>pid</I>.
</DD></DL>
<P>
<I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P><A HREF="sched_getscheduler.html"><B>sched_getscheduler</B>(3)</A>
<B>,</B> the Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;sched.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

98
3rdparty/pthreads4w/manual/sched_yield.html vendored
View File

@ -1,98 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>&quot;SCHED_YIELD&quot;(P) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;14034600">
<META NAME="CHANGED" CONTENT="20050505;14050300">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>sched_yield - yield the processor
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;sched.h&gt; </B>
</P>
<P><B>int sched_yield(void);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>The <B>sched_yield</B> function shall force the running thread to
relinquish the processor until it again becomes the head of its
thread list. It takes no arguments.
</P>
<H2><A HREF="#toc3" NAME="sect3">Return Value</A></H2>
<P>The <B>sched_yield</B> function shall return 0 if it completes
successfully; otherwise, it shall return a value of -1 and set <I>errno</I>
to indicate the error.
</P>
<H2><A HREF="#toc4" NAME="sect4">Errors</A></H2>
<P>No errors are defined.
</P>
<P><I>The following sections are informative.</I>
</P>
<H2><A HREF="#toc5" NAME="sect5">Examples</A></H2>
<P>None.
</P>
<H2><A HREF="#toc6" NAME="sect6">Application Usage</A></H2>
<P>None.
</P>
<H2><A HREF="#toc7" NAME="sect7">Rationale</A></H2>
<P>None.
</P>
<H2><A HREF="#toc8" NAME="sect8">Future Directions</A></H2>
<P>None.
</P>
<H2><A HREF="#toc9" NAME="sect9">See Also</A></H2>
<P>The Base Definitions volume of IEEE&nbsp;Std&nbsp;1003.1-2001,
<I>&lt;sched.h&gt;</I>
</P>
<H2><A HREF="#toc10" NAME="sect10">Copyright</A></H2>
<P>Portions of this text are reprinted and reproduced in electronic
form from IEEE Std 1003.1, 2003 Edition, Standard for Information
Technology -- Portable Operating System Interface (POSIX), The Open
Group Base Specifications Issue 6, Copyright (C) 2001-2003 by the
Institute of Electrical and Electronics Engineers, Inc and The Open
Group. In the event of any discrepancy between this version and the
original IEEE and The Open Group Standard, the original IEEE and The
Open Group Standard is the referee document. The original Standard
can be obtained online at <A HREF="http://www.opengroup.org/unix/online.html">http://www.opengroup.org/unix/online.html</A>
.
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Examples</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Application
Usage</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Rationale</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect8" NAME="toc8">Future
Directions</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect9" NAME="toc9">See
Also</A>
</P>
<LI><P><A HREF="#sect10" NAME="toc10">Copyright</A>
</P>
</UL>
</BODY>
</HTML>

200
3rdparty/pthreads4w/manual/sem_init.html vendored
View File

@ -1,200 +0,0 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
<TITLE>SEMAPHORES(3) manual page</TITLE>
<META NAME="GENERATOR" CONTENT="OpenOffice.org 1.1.3 (Linux)">
<META NAME="CREATED" CONTENT="20050505;14061900">
<META NAME="CHANGED" CONTENT="20050514;195200">
<!-- manual page source format generated by PolyglotMan v3.2, -->
<!-- available at http://polyglotman.sourceforge.net/ -->
</HEAD>
<BODY LANG="en-GB" BGCOLOR="#ffffff" DIR="LTR">
<H4>POSIX Threads for Windows – REFERENCE - <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A></H4>
<P><A HREF="index.html">Reference Index</A></P>
<P><A HREF="#toc">Table of Contents</A></P>
<H2><A HREF="#toc0" NAME="sect0">Name</A></H2>
<P>sem_init, sem_wait, sem_trywait, sem_post, sem_getvalue,
sem_destroy - operations on semaphores
</P>
<H2><A HREF="#toc1" NAME="sect1">Synopsis</A></H2>
<P><B>#include &lt;semaphore.h&gt;</B>
</P>
<P><B>int sem_init(sem_t *</B><I>sem</I><B>, int </B><I>pshared</I><B>,
unsigned int </B><I>value</I><B>);</B>
</P>
<P><B>int sem_wait(sem_t * </B><I>sem</I><B>);</B>
</P>
<P><B>int sem_timedwait(sem_t * </B><I>sem</I>, <B>const struct
timespec *</B><I>abstime</I><B>);</B>
</P>
<P><B>int sem_trywait(sem_t * </B><I>sem</I><B>);</B>
</P>
<P><B>int sem_post(sem_t * </B><I>sem</I><B>);</B>
</P>
<P><B>int sem_post_multiple(sem_t * </B><I>sem, </I><B>int</B>
<I>number</I><B>);</B>
</P>
<P><B>int sem_getvalue(sem_t * </B><I>sem</I><B>, int * </B><I>sval</I><B>);</B>
</P>
<P><B>int sem_destroy(sem_t * </B><I>sem</I><B>);</B>
</P>
<H2><A HREF="#toc2" NAME="sect2">Description</A></H2>
<P>Semaphores are counters for resources shared between threads. The
basic operations on semaphores are: increment the counter atomically,
and wait until the counter is non-null and decrement it atomically.
</P>
<P><B>sem_init</B> initializes the semaphore object pointed to by
<I>sem</I>. The count associated with the semaphore is set initially
to <I>value</I>. The <I>pshared</I> argument indicates whether the
semaphore is local to the current process ( <I>pshared</I> is zero)
or is to be shared between several processes ( <I>pshared</I> is not
zero).</P>
<P><B>Pthreads-w32</B> currently does not support process-shared
semaphores, thus <B>sem_init</B> always returns with error <B>EPERM</B>
if <I>pshared</I> is not zero.
</P>
<P><B>sem_wait</B> atomically decrements <I>sem</I>'s count if it is
greater than 0 and returns immediately or it suspends the calling
thread until it can resume following a call to <B>sem_post</B> or
<B>sem_post_multiple</B>.</P>
<P><B>sem_timedwait</B> atomically decrements <I>sem</I>'s count if
it is greater than 0 and returns immediately, or it suspends the
calling thread. If <I>abstime</I> time arrives before the thread can
resume following a call to <B>sem_post</B> or <B>sem_post_multiple</B>,
then <B>sem_timedwait</B> returns with a return code of -1 after
having set <B>errno</B> to <B>ETIMEDOUT</B>. If the call can return
without suspending then <I>abstime</I> is not checked.</P>
<P><B>sem_trywait</B> atomically decrements <I>sem</I>'s count if it
is greater than 0 and returns immediately, or it returns immediately
with a return code of -1 after having set <B>errno</B> to <B>EAGAIN</B>.
<B>sem_trywait</B> never blocks.</P>
<P><B>sem_post</B> either releases one thread if there are any
waiting on <I>sem</I>, or it atomically increments <I>sem</I>'s
count.</P>
<P><B>sem_post_multiple</B> either releases multiple threads if there
are any waiting on <I>sem</I> and/or it atomically increases <I>sem</I>'s
count. If there are currently <I>n</I> waiters, where <I>n</I> the
largest number less than or equal to <I>number</I>, then <I>n</I>
waiters are released and <I>sem</I>'s count is incremented by <I>number</I>
minus <I>n</I>.</P>
<P><B>sem_getvalue</B> stores in the location pointed to by <I>sval</I>
the current count of the semaphore <I>sem</I>. In the <B>Pthreads-w32</B>
implementation: if the value returned in <I>sval</I> is greater than
or equal to 0 it was the <I>sem</I>'s count at some point during the
call to <B>sem_getvalue</B>. If the value returned in <I>sval</I> is
less than 0 then it's absolute value represents the number of threads
waiting on <I>sem</I> at some point during the call to <B>sem_getvalue.
</B>POSIX does not require an implementation of <B>sem_getvalue</B>
to return a value in <I>sval</I> that is less than 0, but if it does
then it's absolute value must represent the number of waiters.</P>
<P><B>sem_destroy</B> destroys a semaphore object, freeing the
resources it might hold. No threads should be waiting on the
semaphore at the time <B>sem_destroy</B> is called.</P>
<H2><A HREF="#toc3" NAME="sect3">Cancellation</A></H2>
<P><B>sem_wait</B> and <B>sem_timedwait</B> are cancellation points.
</P>
<H2><A HREF="#toc4" NAME="sect4">Async-signal Safety</A></H2>
<P>These routines are not async-cancel safe.</P>
<H2><A HREF="#toc5" NAME="sect5">Return Value</A></H2>
<P>All semaphore functions return 0 on success, or -1 on error in
which case they write an error code in <B>errno</B>.
</P>
<H2><A HREF="#toc6" NAME="sect6">Errors</A></H2>
<P>The <B>sem_init</B> function sets <B>errno</B> to the following
codes on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EINVAL</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<I>value</I> exceeds the maximal counter value <B>SEM_VALUE_MAX</B>
</DD><DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
<B>ENOSYS</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 3cm">
<I>pshared</I> is not zero
</BLOCKQUOTE>
<P>The <B>sem_timedwait</B> function sets <B>errno</B> to the
following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ETIMEDOUT</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 3cm">
if <I>abstime</I> arrives before the waiting thread can resume
following a call to <B>sem_post</B> or <B>sem_post_multiple</B>.
</BLOCKQUOTE>
<P>The <B>sem_trywait</B> function sets <B>errno</B> to the following
error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EAGAIN</B>
</DT></DL>
</DL>
<BLOCKQUOTE STYLE="margin-left: 3cm">
if the semaphore count is currently 0
</BLOCKQUOTE>
<P>The <B>sem_post</B> and <B>sem_post_multiple</B> functions set
<B>errno</B> to the following error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>ERANGE</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
if after incrementing, the semaphore count would exceed
<B>SEM_VALUE_MAX</B> (the semaphore count is left unchanged in this
case)
</DD></DL>
</DL>
<P>
The <B>sem_destroy</B> function sets <B>errno</B> to the following
error code on error:
</P>
<DL>
<DL>
<DT STYLE="margin-right: 1cm; margin-bottom: 0.5cm"><B>EBUSY</B>
</DT><DD STYLE="margin-right: 1cm; margin-bottom: 0.5cm">
if some threads are currently blocked waiting on the semaphore.
</DD></DL>
</DL>
<H2>
<A HREF="#toc7" NAME="sect7">Author</A></H2>
<P>Xavier Leroy &lt;Xavier.Leroy@inria.fr&gt;
</P>
<P>Modified by Ross Johnson for use with <A HREF="http://sources.redhat.com/pthreads-win32">Pthreads-w32</A>.</P>
<H2><A HREF="#toc8" NAME="sect8">See Also</A></H2>
<P><A HREF="pthread_mutex_init.html"><B>pthread_mutex_init</B>(3)</A>
, <A HREF="pthread_cond_init.html"><B>pthread_cond_init</B>(3)</A> ,
<A HREF="pthread_cancel.html"><B>pthread_cancel</B>(3)</A> .
</P>
<HR>
<P><A NAME="toc"></A><B>Table of Contents</B></P>
<UL>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect0" NAME="toc0">Name</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect1" NAME="toc1">Synopsis</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect2" NAME="toc2">Description</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect3" NAME="toc3">Cancellation</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect4" NAME="toc4">Async-signal
Safety</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect5" NAME="toc5">Return
Value</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect6" NAME="toc6">Errors</A>
</P>
<LI><P STYLE="margin-bottom: 0cm"><A HREF="#sect7" NAME="toc7">Author</A>
</P>
<LI><P><A HREF="#sect8" NAME="toc8">See Also</A>
</P>
</UL>
</BODY>
</HTML>

Some files were not shown because too many files have changed in this diff Show More