1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
|
Non-portable functions included in the library
----------------------------------------------
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.
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_mutex_setdefaulttype_np (int newtype, int * oldtype);
The routine sets the default type to be given to all
POSIX mutexes initialised after the function
is called. Any of the following type values
can be made the default type:
PTHREAD_MUTEX_NORMAL
PTHREAD_MUTEX_ERRORCHECK
PTHREAD_MUTEX_RECURSIVE
PTHREAD_MUTEX_DEFAULT
Any mutex initialised with type PTHREAD_MUTEX_DEFAULT
will be set to the mapped type instead. Previously
initialised mutexes are not changed.
When set to PTHREAD_MUTEX_DEFAULT (the initial
value), mutexes will behave as for the
PTHREAD_MUTEX_RECURSIVE type.
If 'oldtype' is a non-NULL pointer, the previous type is
returned through it.
To get the previous type without setting a new type,
use -1 as the 'newtype' value.
Return Values
0 Successfully changed to new type.
[EINVAL] New type isn't valid.
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.
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
after Win32 threads that have called pthreads routines
have exited.
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.
void
pthread_mutexattr_setforcecs_np(pthread_mutexattr_t *attr,
int forcecs);
This function is no longer required as pthreads-win32
mutexes are now based entirely on Win32 critical
sections. Retained for backward compatibility.
Allows an application to force the library to use
critical sections rather than win32 mutexes as
the basis for any mutex that uses "attr".
Critical sections are significantly faster than
mutexes.
Values for "forcecs" are:
PTHREAD_MUTEX_AUTO_CS_NP
- allow the library to decide based on
availability of tryEnterCriticalSection().
The library determines this at runtime
and will use critical sections whenever
tryEnterCriticalSection() is available.
PTHREAD_MUTEX_FORCE_CS_NP
- force use of critical sections even if
tryEnterCriticalSection() isn't provided
by the system, but you'd better not try
to use pthread_mutex_trylock() on any
mutex that uses "attr" if you want your
application to work on all versions of
Windows.
|
