New upstream version 18.0.1+dfsg1
This commit is contained in:
Sebastian Ramacher
parent
f2cf6cce50
commit
c524560d4b
413 changed files with 67546 additions and 0 deletions
483
deps/w32-pthreads/ANNOUNCE
vendored
Normal file
483
deps/w32-pthreads/ANNOUNCE
vendored
Normal file
|
|
@ -0,0 +1,483 @@
|
|||
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
deps/w32-pthreads/BUGS
vendored
Normal file
141
deps/w32-pthreads/BUGS
vendored
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
----------
|
||||
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
deps/w32-pthreads/Bmakefile
vendored
Normal file
268
deps/w32-pthreads/Bmakefile
vendored
Normal file
|
|
@ -0,0 +1,268 @@
|
|||
# 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)
|
||||
26
deps/w32-pthreads/CMakeLists.txt
vendored
Normal file
26
deps/w32-pthreads/CMakeLists.txt
vendored
Normal file
|
|
@ -0,0 +1,26 @@
|
|||
project(w32-pthreads)
|
||||
|
||||
if(NOT WIN32)
|
||||
return()
|
||||
endif()
|
||||
|
||||
set(w32-pthreads_SOURCES
|
||||
pthread.c)
|
||||
|
||||
set(w32-pthreads_HEADERS
|
||||
implement.h
|
||||
pthread.h
|
||||
sched.h
|
||||
semaphore.h)
|
||||
|
||||
add_library(w32-pthreads SHARED
|
||||
${w32-pthreads_SOURCES}
|
||||
${w32-pthreads_HEADERS})
|
||||
target_compile_definitions(w32-pthreads
|
||||
PRIVATE __CLEANUP_C PTW32_BUILD)
|
||||
target_include_directories(w32-pthreads
|
||||
PUBLIC
|
||||
"$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>")
|
||||
target_link_libraries(w32-pthreads)
|
||||
|
||||
install_obs_core(w32-pthreads EXPORT w32-pthreads)
|
||||
140
deps/w32-pthreads/CONTRIBUTORS
vendored
Normal file
140
deps/w32-pthreads/CONTRIBUTORS
vendored
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
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
deps/w32-pthreads/COPYING
vendored
Normal file
150
deps/w32-pthreads/COPYING
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
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.
|
||||
51 Franklin Street
|
||||
Fifth Floor
|
||||
Boston, MA 02110-1301
|
||||
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
deps/w32-pthreads/COPYING.LIB
vendored
Normal file
504
deps/w32-pthreads/COPYING.LIB
vendored
Normal file
|
|
@ -0,0 +1,504 @@
|
|||
GNU LESSER GENERAL PUBLIC LICENSE
|
||||
Version 2.1, February 1999
|
||||
|
||||
Copyright (C) 1991, 1999 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/ChangeLog
vendored
Normal file
5211
deps/w32-pthreads/ChangeLog
vendored
Normal file
File diff suppressed because it is too large
Load diff
451
deps/w32-pthreads/FAQ
vendored
Normal file
451
deps/w32-pthreads/FAQ
vendored
Normal file
|
|
@ -0,0 +1,451 @@
|
|||
=========================================
|
||||
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
deps/w32-pthreads/GNUmakefile
vendored
Normal file
593
deps/w32-pthreads/GNUmakefile
vendored
Normal file
|
|
@ -0,0 +1,593 @@
|
|||
#
|
||||
# --------------------------------------------------------------------------
|
||||
#
|
||||
# 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.,
|
||||
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/MAINTAINERS
vendored
Normal file
4
deps/w32-pthreads/MAINTAINERS
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
CVS Repository maintainers
|
||||
|
||||
Ross Johnson rpj@ise.canberra.edu.au
|
||||
Ben Elliston bje@cygnus.com
|
||||
514
deps/w32-pthreads/Makefile
vendored
Normal file
514
deps/w32-pthreads/Makefile
vendored
Normal file
|
|
@ -0,0 +1,514 @@
|
|||
# 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
deps/w32-pthreads/NEWS
vendored
Normal file
1241
deps/w32-pthreads/NEWS
vendored
Normal file
File diff suppressed because it is too large
Load diff
24
deps/w32-pthreads/Nmakefile
vendored
Normal file
24
deps/w32-pthreads/Nmakefile
vendored
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
/*
|
||||
* 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
deps/w32-pthreads/Nmakefile.tests
vendored
Normal file
260
deps/w32-pthreads/Nmakefile.tests
vendored
Normal file
|
|
@ -0,0 +1,260 @@
|
|||
/* 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
deps/w32-pthreads/PROGRESS
vendored
Normal file
4
deps/w32-pthreads/PROGRESS
vendored
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
Please see the ANNOUNCE file "Level of Standards Conformance"
|
||||
or the web page:
|
||||
|
||||
http://sources.redhat.com/pthreads-win32/conformance.html
|
||||
601
deps/w32-pthreads/README
vendored
Normal file
601
deps/w32-pthreads/README
vendored
Normal file
|
|
@ -0,0 +1,601 @@
|
|||
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
deps/w32-pthreads/README.Borland
vendored
Normal file
57
deps/w32-pthreads/README.Borland
vendored
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
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
deps/w32-pthreads/README.CV
vendored
Normal file
3036
deps/w32-pthreads/README.CV
vendored
Normal file
File diff suppressed because it is too large
Load diff
783
deps/w32-pthreads/README.NONPORTABLE
vendored
Normal file
783
deps/w32-pthreads/README.NONPORTABLE
vendored
Normal file
|
|
@ -0,0 +1,783 @@
|
|||
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
deps/w32-pthreads/README.Watcom
vendored
Normal file
62
deps/w32-pthreads/README.Watcom
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
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
deps/w32-pthreads/README.WinCE
vendored
Normal file
6
deps/w32-pthreads/README.WinCE
vendored
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
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
deps/w32-pthreads/TODO
vendored
Normal file
7
deps/w32-pthreads/TODO
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
Things that aren't done yet
|
||||
---------------------------
|
||||
|
||||
1. Implement PTHREAD_PROCESS_SHARED for semaphores, mutexes,
|
||||
condition variables, read/write locks, barriers.
|
||||
|
||||
|
||||
222
deps/w32-pthreads/WinCE-PORT
vendored
Normal file
222
deps/w32-pthreads/WinCE-PORT
vendored
Normal file
|
|
@ -0,0 +1,222 @@
|
|||
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
deps/w32-pthreads/attr.c
vendored
Normal file
53
deps/w32-pthreads/attr.c
vendored
Normal file
|
|
@ -0,0 +1,53 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/autostatic.c
vendored
Normal file
69
deps/w32-pthreads/autostatic.c
vendored
Normal file
|
|
@ -0,0 +1,69 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/barrier.c
vendored
Normal file
47
deps/w32-pthreads/barrier.c
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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"
|
||||
9
deps/w32-pthreads/builddmc.bat
vendored
Normal file
9
deps/w32-pthreads/builddmc.bat
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
; 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
deps/w32-pthreads/cancel.c
vendored
Normal file
44
deps/w32-pthreads/cancel.c
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
|
||||
|
||||
#include "pthread_setcancelstate.c"
|
||||
#include "pthread_setcanceltype.c"
|
||||
#include "pthread_testcancel.c"
|
||||
#include "pthread_cancel.c"
|
||||
148
deps/w32-pthreads/cleanup.c
vendored
Normal file
148
deps/w32-pthreads/cleanup.c
vendored
Normal file
|
|
@ -0,0 +1,148 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/condvar.c
vendored
Normal file
50
deps/w32-pthreads/condvar.c
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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"
|
||||
153
deps/w32-pthreads/config.h
vendored
Normal file
153
deps/w32-pthreads/config.h
vendored
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
/* 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 defined(__BORLANDC__)
|
||||
#endif
|
||||
|
||||
#if defined(__WATCOMC__)
|
||||
#endif
|
||||
|
||||
#if defined(__DMC__)
|
||||
#define HAVE_SIGNAL_H
|
||||
#define HAVE_C_INLINE
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
74
deps/w32-pthreads/context.h
vendored
Normal file
74
deps/w32-pthreads/context.h
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/create.c
vendored
Normal file
308
deps/w32-pthreads/create.c
vendored
Normal file
|
|
@ -0,0 +1,308 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/dll.c
vendored
Normal file
92
deps/w32-pthreads/dll.c
vendored
Normal file
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/errno.c
vendored
Normal file
94
deps/w32-pthreads/errno.c
vendored
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/exit.c
vendored
Normal file
44
deps/w32-pthreads/exit.c
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
#if ! defined(_UWIN) && ! defined(WINCE)
|
||||
# include <process.h>
|
||||
#endif
|
||||
|
||||
#include "pthread_exit.c"
|
||||
39
deps/w32-pthreads/fork.c
vendored
Normal file
39
deps/w32-pthreads/fork.c
vendored
Normal file
|
|
@ -0,0 +1,39 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
107
deps/w32-pthreads/global.c
vendored
Normal file
107
deps/w32-pthreads/global.c
vendored
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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
deps/w32-pthreads/implement.h
vendored
Normal file
943
deps/w32-pthreads/implement.h
vendored
Normal file
|
|
@ -0,0 +1,943 @@
|
|||
/*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 */
|
||||
BIN
deps/w32-pthreads/libpthreadGC2.a
vendored
Normal file
BIN
deps/w32-pthreads/libpthreadGC2.a
vendored
Normal file
Binary file not shown.
1
deps/w32-pthreads/libpthreadGC2.stamp
vendored
Normal file
1
deps/w32-pthreads/libpthreadGC2.stamp
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
touched
|
||||
74
deps/w32-pthreads/manual/ChangeLog
vendored
Normal file
74
deps/w32-pthreads/manual/ChangeLog
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
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
deps/w32-pthreads/manual/PortabilityIssues.html
vendored
Normal file
718
deps/w32-pthreads/manual/PortabilityIssues.html
vendored
Normal file
|
|
@ -0,0 +1,718 @@
|
|||
<!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
deps/w32-pthreads/manual/index.html
vendored
Normal file
158
deps/w32-pthreads/manual/index.html
vendored
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
<!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
deps/w32-pthreads/manual/pthreadCancelableWait.html
vendored
Normal file
86
deps/w32-pthreads/manual/pthreadCancelableWait.html
vendored
Normal file
|
|
@ -0,0 +1,86 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_attr_init.html
vendored
Normal file
280
deps/w32-pthreads/manual/pthread_attr_init.html
vendored
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_attr_setstackaddr.html
vendored
Normal file
158
deps/w32-pthreads/manual/pthread_attr_setstackaddr.html
vendored
Normal file
|
|
@ -0,0 +1,158 @@
|
|||
<!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_GETSTACKADDR"(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 <pthread.h> </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
|
||||
"stack" does not specify a particular relationship between
|
||||
the address and the "stack" 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 "up" from low memory to high, and on which a
|
||||
"push" operation first stores the value in memory and then
|
||||
increments the stack pointer register. Further, on a machine where
|
||||
the stack grows "down" from high memory to low,
|
||||
interpretation of the address as the "low memory" address
|
||||
requires a determination of the intended size of the stack.
|
||||
IEEE Std 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 Std 1003.1-2001,
|
||||
<I><limits.h></I>, <I><pthread.h></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
deps/w32-pthreads/manual/pthread_attr_setstacksize.html
vendored
Normal file
127
deps/w32-pthreads/manual/pthread_attr_setstacksize.html
vendored
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
<!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_GETSTACKSIZE"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><limits.h></I>, <I><pthread.h></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
deps/w32-pthreads/manual/pthread_barrier_init.html
vendored
Normal file
197
deps/w32-pthreads/manual/pthread_barrier_init.html
vendored
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
<!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_BARRIER_DESTROY"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_barrier_wait.html
vendored
Normal file
161
deps/w32-pthreads/manual/pthread_barrier_wait.html
vendored
Normal file
|
|
@ -0,0 +1,161 @@
|
|||
<!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_BARRIER_WAIT"(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 <pthread.h> </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><pthread.h></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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_barrierattr_init.html
vendored
Normal file
142
deps/w32-pthreads/manual/pthread_barrierattr_init.html
vendored
Normal file
|
|
@ -0,0 +1,142 @@
|
|||
<!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_BARRIERATTR_DESTROY"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_barrierattr_setpshared.html
vendored
Normal file
159
deps/w32-pthreads/manual/pthread_barrierattr_setpshared.html
vendored
Normal file
|
|
@ -0,0 +1,159 @@
|
|||
<!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_BARRIERATTR_GETPSHARED"(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 <pthread.h> </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><pthread.h></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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_cancel.html
vendored
Normal file
205
deps/w32-pthreads/manual/pthread_cancel.html
vendored
Normal file
|
|
@ -0,0 +1,205 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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, &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
deps/w32-pthreads/manual/pthread_cleanup_push.html
vendored
Normal file
140
deps/w32-pthreads/manual/pthread_cleanup_push.html
vendored
Normal file
|
|
@ -0,0 +1,140 @@
|
|||
<!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 <pthread.h></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
|
||||
<Xavier.Leroy@inria.fr>
|
||||
</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 *) &mut);
|
||||
pthread_mutex_lock(&mut);
|
||||
/* do some work */
|
||||
pthread_mutex_unlock(&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, &oldtype);
|
||||
pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
|
||||
pthread_mutex_lock(&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
deps/w32-pthreads/manual/pthread_cond_init.html
vendored
Normal file
313
deps/w32-pthreads/manual/pthread_cond_init.html
vendored
Normal file
|
|
@ -0,0 +1,313 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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(&mut);
|
||||
while (x <= y) {
|
||||
pthread_cond_wait(&cond, &mut);
|
||||
}
|
||||
/* operate on x and y */
|
||||
pthread_mutex_unlock(&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(&mut);
|
||||
/* modify x and y */
|
||||
if (x > y) pthread_cond_broadcast(&cond);
|
||||
pthread_mutex_unlock(&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(&mut);
|
||||
gettimeofday(&now);
|
||||
timeout.tv_sec = now.tv_sec + 5;
|
||||
timeout.tv_nsec = now.tv_usec * 1000;
|
||||
retcode = 0;
|
||||
while (x <= y && retcode != ETIMEDOUT) {
|
||||
retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
|
||||
}
|
||||
if (retcode == ETIMEDOUT) {
|
||||
/* timeout occurred */
|
||||
} else {
|
||||
/* operate on x and y */
|
||||
}
|
||||
pthread_mutex_unlock(&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
deps/w32-pthreads/manual/pthread_condattr_init.html
vendored
Normal file
98
deps/w32-pthreads/manual/pthread_condattr_init.html
vendored
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_condattr_setpshared.html
vendored
Normal file
153
deps/w32-pthreads/manual/pthread_condattr_setpshared.html
vendored
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
<!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_GETPSHARED"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_create.html
vendored
Normal file
94
deps/w32-pthreads/manual/pthread_create.html
vendored
Normal file
|
|
@ -0,0 +1,94 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_delay_np.html
vendored
Normal file
71
deps/w32-pthreads/manual/pthread_delay_np.html
vendored
Normal file
|
|
@ -0,0 +1,71 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_detach.html
vendored
Normal file
90
deps/w32-pthreads/manual/pthread_detach.html
vendored
Normal file
|
|
@ -0,0 +1,90 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_equal.html
vendored
Normal file
48
deps/w32-pthreads/manual/pthread_equal.html
vendored
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
<!-- 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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
<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
deps/w32-pthreads/manual/pthread_exit.html
vendored
Normal file
59
deps/w32-pthreads/manual/pthread_exit.html
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
<!-- 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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
<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
deps/w32-pthreads/manual/pthread_getunique_np.html
vendored
Normal file
76
deps/w32-pthreads/manual/pthread_getunique_np.html
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_getw32threadhandle_np.html
vendored
Normal file
57
deps/w32-pthreads/manual/pthread_getw32threadhandle_np.html
vendored
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_join.html
vendored
Normal file
118
deps/w32-pthreads/manual/pthread_join.html
vendored
Normal file
|
|
@ -0,0 +1,118 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_key_create.html
vendored
Normal file
211
deps/w32-pthreads/manual/pthread_key_create.html
vendored
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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(&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(&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
deps/w32-pthreads/manual/pthread_kill.html
vendored
Normal file
152
deps/w32-pthreads/manual/pthread_kill.html
vendored
Normal file
|
|
@ -0,0 +1,152 @@
|
|||
<!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 <pthread.h></B> <BR><B>#include <signal.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_mutex_init.html
vendored
Normal file
356
deps/w32-pthreads/manual/pthread_mutex_init.html
vendored
Normal file
|
|
@ -0,0 +1,356 @@
|
|||
<!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 <pthread.h></B>
|
||||
</P>
|
||||
<P><B>#include <time.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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(&mut);
|
||||
/* operate on x */
|
||||
pthread_mutex_unlock(&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
deps/w32-pthreads/manual/pthread_mutexattr_init.html
vendored
Normal file
207
deps/w32-pthreads/manual/pthread_mutexattr_init.html
vendored
Normal file
|
|
@ -0,0 +1,207 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_mutexattr_setpshared.html
vendored
Normal file
151
deps/w32-pthreads/manual/pthread_mutexattr_setpshared.html
vendored
Normal file
|
|
@ -0,0 +1,151 @@
|
|||
<!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_GETPSHARED"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_num_processors_np.html
vendored
Normal file
57
deps/w32-pthreads/manual/pthread_num_processors_np.html
vendored
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_once.html
vendored
Normal file
83
deps/w32-pthreads/manual/pthread_once.html
vendored
Normal file
|
|
@ -0,0 +1,83 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_rwlock_init.html
vendored
Normal file
193
deps/w32-pthreads/manual/pthread_rwlock_init.html
vendored
Normal file
|
|
@ -0,0 +1,193 @@
|
|||
<!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_RWLOCK_DESTROY"(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 <pthread.h> </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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_rwlock_rdlock.html
vendored
Normal file
168
deps/w32-pthreads/manual/pthread_rwlock_rdlock.html
vendored
Normal file
|
|
@ -0,0 +1,168 @@
|
|||
<!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_RWLOCK_RDLOCK"(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 <pthread.h> </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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_rwlock_timedrdlock.html
vendored
Normal file
156
deps/w32-pthreads/manual/pthread_rwlock_timedrdlock.html
vendored
Normal file
|
|
@ -0,0 +1,156 @@
|
|||
<!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_RWLOCK_TIMEDRDLOCK"(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 <pthread.h> <BR></B>#include <time.h>
|
||||
</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><time.h></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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></I>, <I><time.h></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
deps/w32-pthreads/manual/pthread_rwlock_timedwrlock.html
vendored
Normal file
150
deps/w32-pthreads/manual/pthread_rwlock_timedwrlock.html
vendored
Normal file
|
|
@ -0,0 +1,150 @@
|
|||
<!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_RWLOCK_TIMEDWRLOCK"(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 <pthread.h> <BR></B>#include <time.h>
|
||||
</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><time.h></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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></I>, <I><time.h></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
deps/w32-pthreads/manual/pthread_rwlock_unlock.html
vendored
Normal file
141
deps/w32-pthreads/manual/pthread_rwlock_unlock.html
vendored
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
<!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_RWLOCK_UNLOCK"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_rwlock_wrlock.html
vendored
Normal file
153
deps/w32-pthreads/manual/pthread_rwlock_wrlock.html
vendored
Normal file
|
|
@ -0,0 +1,153 @@
|
|||
<!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_RWLOCK_TRYWRLOCK"(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 <pthread.h> </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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_rwlockattr_init.html
vendored
Normal file
141
deps/w32-pthreads/manual/pthread_rwlockattr_init.html
vendored
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
<!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_RWLOCKATTR_DESTROY"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_rwlockattr_setpshared.html
vendored
Normal file
160
deps/w32-pthreads/manual/pthread_rwlockattr_setpshared.html
vendored
Normal file
|
|
@ -0,0 +1,160 @@
|
|||
<!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_RWLOCKATTR_GETPSHARED"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_self.html
vendored
Normal file
70
deps/w32-pthreads/manual/pthread_self.html
vendored
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_setcancelstate.html
vendored
Normal file
207
deps/w32-pthreads/manual/pthread_setcancelstate.html
vendored
Normal file
|
|
@ -0,0 +1,207 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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, &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
deps/w32-pthreads/manual/pthread_setcanceltype.html
vendored
Normal file
207
deps/w32-pthreads/manual/pthread_setcanceltype.html
vendored
Normal file
|
|
@ -0,0 +1,207 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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, &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
deps/w32-pthreads/manual/pthread_setconcurrency.html
vendored
Normal file
155
deps/w32-pthreads/manual/pthread_setconcurrency.html
vendored
Normal file
|
|
@ -0,0 +1,155 @@
|
|||
<!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_GETCONCURRENCY"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_setschedparam.html
vendored
Normal file
114
deps/w32-pthreads/manual/pthread_setschedparam.html
vendored
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
<!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 <pthread.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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
deps/w32-pthreads/manual/pthread_spin_init.html
vendored
Normal file
176
deps/w32-pthreads/manual/pthread_spin_init.html
vendored
Normal file
|
|
@ -0,0 +1,176 @@
|
|||
<!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_SPIN_DESTROY"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_spin_lock.html
vendored
Normal file
141
deps/w32-pthreads/manual/pthread_spin_lock.html
vendored
Normal file
|
|
@ -0,0 +1,141 @@
|
|||
<!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_SPIN_LOCK"(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 <pthread.h> </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 Std 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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_spin_unlock.html
vendored
Normal file
124
deps/w32-pthreads/manual/pthread_spin_unlock.html
vendored
Normal file
|
|
@ -0,0 +1,124 @@
|
|||
<!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_SPIN_UNLOCK"(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 <pthread.h> </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 Std 1003.1-2001,
|
||||
<I><pthread.h></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
deps/w32-pthreads/manual/pthread_timechange_handler_np.html
vendored
Normal file
76
deps/w32-pthreads/manual/pthread_timechange_handler_np.html
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_win32_attach_detach_np.html
vendored
Normal file
74
deps/w32-pthreads/manual/pthread_win32_attach_detach_np.html
vendored
Normal file
|
|
@ -0,0 +1,74 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/pthread_win32_test_features_np.html
vendored
Normal file
68
deps/w32-pthreads/manual/pthread_win32_test_features_np.html
vendored
Normal file
|
|
@ -0,0 +1,68 @@
|
|||
<!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 <pthread.h></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
deps/w32-pthreads/manual/sched_get_priority_max.html
vendored
Normal file
115
deps/w32-pthreads/manual/sched_get_priority_max.html
vendored
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
|
||||
<TITLE>"SCHED_GET_PRIORITY_MAX"(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 <sched.h> </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><sched.h></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 Std 1003.1-2001,
|
||||
<I><sched.h></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
deps/w32-pthreads/manual/sched_getscheduler.html
vendored
Normal file
127
deps/w32-pthreads/manual/sched_getscheduler.html
vendored
Normal file
|
|
@ -0,0 +1,127 @@
|
|||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
|
||||
<TITLE>"SCHED_GETSCHEDULER"(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 <sched.h> </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><sched.h></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 Std 1003.1-2001,
|
||||
<I><sched.h></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
deps/w32-pthreads/manual/sched_setscheduler.html
vendored
Normal file
181
deps/w32-pthreads/manual/sched_setscheduler.html
vendored
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
|
||||
<TITLE>"SCHED_SETSCHEDULER"(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 <sched.h> </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><sched.h></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 Std 1003.1-2001,
|
||||
<I><sched.h></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
deps/w32-pthreads/manual/sched_yield.html
vendored
Normal file
98
deps/w32-pthreads/manual/sched_yield.html
vendored
Normal file
|
|
@ -0,0 +1,98 @@
|
|||
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
|
||||
<HTML>
|
||||
<HEAD>
|
||||
<META HTTP-EQUIV="CONTENT-TYPE" CONTENT="text/html; charset=utf-8">
|
||||
<TITLE>"SCHED_YIELD"(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 <sched.h> </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 Std 1003.1-2001,
|
||||
<I><sched.h></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
deps/w32-pthreads/manual/sem_init.html
vendored
Normal file
200
deps/w32-pthreads/manual/sem_init.html
vendored
Normal file
|
|
@ -0,0 +1,200 @@
|
|||
<!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 <semaphore.h></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 <Xavier.Leroy@inria.fr>
|
||||
</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>
|
||||
50
deps/w32-pthreads/misc.c
vendored
Normal file
50
deps/w32-pthreads/misc.c
vendored
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* misc.c
|
||||
*
|
||||
* Description:
|
||||
* This translation unit implements miscellaneous thread functions.
|
||||
*
|
||||
* --------------------------------------------------------------------------
|
||||
*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
|
||||
|
||||
#include "pthread_kill.c"
|
||||
#include "pthread_once.c"
|
||||
#include "pthread_self.c"
|
||||
#include "pthread_equal.c"
|
||||
#include "pthread_setconcurrency.c"
|
||||
#include "pthread_getconcurrency.c"
|
||||
#include "ptw32_new.c"
|
||||
#include "ptw32_calloc.c"
|
||||
#include "ptw32_reuse.c"
|
||||
#include "w32_CancelableWait.c"
|
||||
62
deps/w32-pthreads/mutex.c
vendored
Normal file
62
deps/w32-pthreads/mutex.c
vendored
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
/*
|
||||
* mutex.c
|
||||
*
|
||||
* Description:
|
||||
* This translation unit implements mutual exclusion (mutex) 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#if ! defined(_UWIN) && ! defined(WINCE)
|
||||
# include <process.h>
|
||||
#endif
|
||||
#if !defined(NEED_FTIME)
|
||||
#include <sys/timeb.h>
|
||||
#endif
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
|
||||
|
||||
#include "ptw32_mutex_check_need_init.c"
|
||||
#include "pthread_mutex_init.c"
|
||||
#include "pthread_mutex_destroy.c"
|
||||
#include "pthread_mutexattr_init.c"
|
||||
#include "pthread_mutexattr_destroy.c"
|
||||
#include "pthread_mutexattr_getpshared.c"
|
||||
#include "pthread_mutexattr_setpshared.c"
|
||||
#include "pthread_mutexattr_settype.c"
|
||||
#include "pthread_mutexattr_gettype.c"
|
||||
#include "pthread_mutexattr_setrobust.c"
|
||||
#include "pthread_mutexattr_getrobust.c"
|
||||
#include "pthread_mutex_lock.c"
|
||||
#include "pthread_mutex_timedlock.c"
|
||||
#include "pthread_mutex_unlock.c"
|
||||
#include "pthread_mutex_trylock.c"
|
||||
#include "pthread_mutex_consistent.c"
|
||||
47
deps/w32-pthreads/nonportable.c
vendored
Normal file
47
deps/w32-pthreads/nonportable.c
vendored
Normal file
|
|
@ -0,0 +1,47 @@
|
|||
/*
|
||||
* nonportable.c
|
||||
*
|
||||
* Description:
|
||||
* This translation unit implements non-portable thread functions.
|
||||
*
|
||||
* --------------------------------------------------------------------------
|
||||
*
|
||||
* 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.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
|
||||
*/
|
||||
|
||||
#include "pthread.h"
|
||||
#include "implement.h"
|
||||
|
||||
#include "pthread_mutexattr_setkind_np.c"
|
||||
#include "pthread_mutexattr_getkind_np.c"
|
||||
#include "pthread_getw32threadhandle_np.c"
|
||||
#include "pthread_getunique_np.c"
|
||||
#include "pthread_delay_np.c"
|
||||
#include "pthread_num_processors_np.c"
|
||||
#include "pthread_win32_attach_detach_np.c"
|
||||
#include "pthread_timechange_handler_np.c"
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue