concurrency.
pthread_setconcurrency
int pthread_getconcurrency (int new_level);
Allows the application to inform the threads implementation of its desired minimum concurrency level. The actual level of concurrency resulting from this call is unspecified.
References: 5.6.3, 10.1.3
Errors: [EINVAL] new_level is negative.
[EAGAIN] new_level exceeds a system resource.
Hint: Concurrency level is a hint. It may be ignored by any implementa-
tion, and
10.1.4 Stack guard size
Guard size comes from DCE threads. Most thread implementations add to the thread's stack a 'guard' region, a page or more of protected memory. This protected page is a safety zone, to prevent a stack overflow in one thread from corrupting another thread's stack. There are two good reasons for wanting to control a thread's guard size:
1. It allows an application or library that allocates large data arrays on the stack to increase the default guard size. For example, if a thread allocates two pages at once, a single guard page provides little protection against stack overflows — the thread can corrupt adjoining memory without touching the protected page.
2. When creating a large number of threads, it may be that the extra page for each stack can become a severe burden. In addition to the extra page, the kernel's memory manager has to keep track of the differing protection on adjoining pages, which may strain system resources. Therefore, you may sometimes need to ask the system to 'trust you' and avoid allocating any guard pages at all for your threads. You can do this by requesting a guard size of 0 bytes.
pthread_attr_getguardsize
int pthread_attr_getguardsize (
const pthread_attr_t *attr, size_t *guardsize);
Determine the size of the guard region for the stack on which threads created with attr will run.
References: 2, 5.2.3
Errors: [EINVAL] attr invalid.
Hint: Specify 0 to fit lots of stacks in an address space, or increase default
guardsize for threads that allocate large buffers on the stack.
pthread_attr_setguardsize
int pthread_attr_setguardsize (
pthread_attr_t *attr,
size_t guardsize);
Threads created with attr will run on a stack with guardsize bytes protected against stack overflow. The implementation may round guardsize up to the next multiple of PAGESIZE. Specifying a value of 0 for guardsize will cause threads created using the attributes object to run without stack overflow protection.
References: 2, 5.2.3
Errors: [EINVAL] guardsize or attr invalid.
Hint: Specify 0 to fit lots of stacks in an address space, or increase default
guardsize for threads that allocate large buffers on the stack.
10.1.5 Parallel I/O
Many high-performance systems, such as database engines, use threads, at least in part, to gain performance through parallel I/O. Unfortunately, Pthreads doesn't directly support parallel I/O. That is, two threads can independently issue I/O operations for files, or even for the same file, but the POSIX file I/O model places some restrictions on the level of parallelism.
One bottleneck is that the current file position is an attribute of the file descriptor. To read or write data from or to a specific position within a file, a thread must call lseek to seek to the proper byte offset in the file, and then read or write. If more than one thread does this at the same time, the first thread might seek, and then the second thread seek to a different place before the first thread can issue the read or write operation.
The X/Open pread and pwrite functions offer a solution, by making the seek and read or write combination atomic. Threads can issue pread or pwrite operations in parallel, and, in principle, the system can process those I/O requests completely in parallel without locking the file descriptor.
pread
size_t pread (
int fildes,
void *buf,
size_t nbyte,
off_t offset);
Read nbyte bytes from offset offset in the file opened on file descriptor fildes, placing the result into buf. The file descriptor's current offset is not affected, allowing multiple pread and/or pwrite operations to proceed in parallel.
References: none
Errors: [EINVAL]offsetisnegative.
[EOVERFLOW] attempt to read beyond maximum.
[ENXIO] request outside capabilities of device.
[ESPiPE] file is pipe. Hint: Allows high-performance parallel I/O.
pwrite
size_t pwrite (
int fildes,
const void *buf,
size_t nbyte,
off_t offset);
Write nbyte bytes to offset offset in the file opened on file descriptor fildes, from buf. The file descriptor's current offset is not affected, allowing multiplepread and/ or pwrite operations to proceed in parallel.
References: none
Errors: [EINVAL] offset is negative.
[ESPIPE] file is pipe. Hint: Allows high-performance parallel I/O.
10.1.6 Cancellation points
Most UNIX systems support a substantial number of interfaces that do not come from POSIX. The select and poll interfaces, for example, should be deferred cancellation points. Pthreads did not require these functions to be cancellation points, however, because they do not exist within POSIX. 1.
The select and poll functions, however, along with many others, exist in X/Open. The XSH5 standard includes an expanded list of cancellation points covering X/Open interfaces.
Additional functions that must be cancellation points in XSH5:
