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. 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. 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 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. 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 certain pthreads routines. Call this routine when the Win32 thread exits. 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.