Document revision date: 19 July 1999

The following are routines in the DECthreads pthread interface that did not exist at the time of the implementation of the d4 interface:

• pthread_atfork() (DIGITAL UNIX only)
• pthread_attr_getdetachstate()
• pthread_attr_setdetachstate()
• pthread_key_delete()
• pthread_kill() (DIGITAL UNIX only)
• pthread_sigmask() (DIGITAL UNIX only)

actual granularity: Granularity for a program; limited by the granularities made available by the processor, but determined by the code produced by the compiler. See also granularity, natural granularity, and system granularity.

address exception: An exception whose identity is based on where in the program it was raised. See also exception and status exception.

alert: See cancelation request.

alertable routine: See cancelable routine.

AST: Mechanism that signals an asynchronous event to a process.

asynchronous cancelability: If enabled, allows a thread to receive a cancelation request at any time (not only at cancelation points). See also general cancelability.

asynchronous signal: Signal that is the result of an event that is external to the process and is delivered at any point in a thread's execution when such an event occurs. See also synchronous signal.

attributes: Individual components of the attributes object. Attributes specify detailed properties about the objects to be created. See also attributes object.

attributes object: Object used to describe DECthreads objects (thread, mutex, condition variable, or queue). This description consists of the individual attribute values that are used to create an object. See also attributes.

bugcheck: An error condition internal to the DECthreads run-time environment that causes it to produce a specially formatted error message. Output of this message can be controlled using the PTHREAD_CONFIG environment variable or logical symbol.

cancelability state: Attribute of a thread that determines whether it currently receives cancelation requests.

cancelability type: Attribute of a thread that determines whether it responds to a cancelation request at cancelation points (synchronous concelation) or at any point in its execution (asynchronous cancelation).

cancelation point: A routine that, when called, determines whether a cancelation request is pending for this thread.

cancelation request: Mechanism by which one thread requests termination of another thread (or itself).

condition variable: Object that allows a thread to block its own execution until some shared data reaches a particular state.

condition variable attributes object: Object that allows you to specify values for condition variable attributes when you create a condition variable.

contention scope: Attribute of a thread that specifies the set of threads with which it competes for processing resources. See also process contention scope and system contention scope.

deadlock: Condition involving one or more threads and a set of one or more resources in which each of the threads is blocked waiting for one of the resources and all of the resources are held by the threads such that none of the threads can continue. For example, a thread will enter a self-deadlock when it attempts to lock a normal mutex a second time. Likewise, two threads will enter a deadlock when each attempts to lock a second mutex that is already held by the other. The introduction of additional threads and synchronization objects allows for more complex deadlock configurations.

dynamic memory: Memory that is allocated by the program as a result of a call to some memory management function, and that is referenced through pointer variables. See also static memory and stack memory.

epilogue code: Block of code, associated with a DECthreads exception scope, that finalizes the context of an exception scope. Epilogue code is always executed, regardless of whether the code in the associated exception scope raised an exception.

errorcheck mutex: Mutex that can be locked exactly once by a thread, like a normal mutex. If a thread tries to lock the mutex again without first unlocking it, the thread receives an error instead of deadlocking. See also deadlock, mutex, normal mutex, and recursive mutex.

exception: Object that describes an error condition.

exception scope: Block of code where exceptions are handled.

finalization code: See epilogue code.

general cancelability: If enabled, allows a thread to receive a cancelation request at specific cancelation points. If disabled, the thread cannot be canceled. See also asynchronous cancelability.

global lock: Single recursive mutex provided by DECthreads for use by all threads in a process when calling routines or code that is not thread safe to ensure serialized, exclusive access to the unsafe code.

granularity: Smallest unit of storage (that is, bytes, words, longwords, or quadwords) that a computer can load or store in one machine instruction. See also actual granularity, natural granularity, and system granularity.

guard area: Area at the overflow end of the thread stack that is inaccessible to the thread. This helps prevent or detect overflow of the thread's stack.

guard pages: Low-level memory regions that form a stack guard region.

guardsize attribute: Attribute of a thread that specifies the minimum size (in bytes) of the guard area for a thread's stack.

handle: Storage, similar to a pointer, that refers to a specific DECthreads object.

inherit scheduling attribute: Attribute of a thread that specifies whether a newly created thread inherits the scheduling attributes (scheduling priority and policy) of the creating thread or uses the scheduling attributes stored in the attributes object. See also thread attributes object.

kernel execution context: Entity managed by the operating system kernel that uses processing resources. Also known as a kernel thread or virtual processor.

lifetime: Length of time memory is allocated for a particular purpose.

lock acquisition: Each instance of acquiring a mutex or read-write lock.

multithreaded programming: Division of a program into multiple threads that execute concurrently.

mutex: Mutual exclusion, an object that multiple threads use to ensure the integrity of a shared resource that they access (most commonly shared data) by allowing only one thread to access it at a time. See also normal mutex, errorcheck mutex, and recursive mutex.

mutex attributes object: Object that allows you to specify values for mutex attributes when you create a mutex.

mutex kind attribute: Mutex attribute that specifies whether its kind is normal, recursive, or errorcheck.

natural granularity: Granularity of a processor; determined by the processor's architecture, cache architecture, and instruction set. See also actual granularity, granularity, and system granularity.

nonterminating signal: Signal that does not result in the termination of the process by default. See also terminating signal.

normal mutex: A kind of mutex that can be locked exactly once by a thread. It does not perform error checks. If a thread tries to lock the mutex again without first unlocking it, the thread waits for itself to release the lock and deadlocks. In DECthreads, this kind of mutex offers the best performance. See also mutex, errorcheck mutex, and recursive mutex.

per-thread context: See thread-specific data.

predicate: Boolean expression that defines a particular state of shared data; threads wait on a condition variable for shared data to enter the defined state. See also condition variable.

priority inversion: Occurs when interaction among three or more threads blocks the highest-priority thread from executing until after the lowest-priority thread can execute.

process contention scope: Setting for the contention scope attribute of a thread. Specifies that a thread competes for processing resources only with other threads in the same process. See also contention scope and system contention scope.

race condition: Occurs when two or more threads perform an operation, and the result of the operation depends on unpredictable timing factors.

read-write lock: An object that serializes access, in a thread-safe manner, to a data object that is shared among threads and that is frequently read but less frequently written.

recursive mutex: Mutex that can be locked more than once by a given thread without causing a deadlock. The thread must call the pthread_mutex_unlock() routine the same number of times that it called the pthread_mutex_lock() routine before another thread can lock the mutex. See also deadlock, mutex, normal mutex, and errorcheck mutex.

scheduling policy attribute: Attribute of a thread that describes how the thread is scheduled for execution relative to the other threads in the program. See also thread attributes object.

scheduling precedence: The set of characteristics of threads and the DECthreads scheduling algorithm that, in combination, determine which thread will be allowed to run when a scheduling decision is made. Scheduling decisions are made when a thread becomes ready to run (for example, when a mutex on which it was waiting is unlocked, or a condition variable on which it was waiting is signaled or broadcasted), or when a thread is blocked (for example, when it attempts to lock a locked mutex or when it waits on a condition variable).

scheduling priority attribute: Attribute of a thread that specifies the execution priority of a thread, expressed relative to other threads in the same policy. See also thread attributes object.

scope: Areas of a program where code can access memory.

software interrupt handler: A routine that is executed in response to an interrupt generated by the operating system or equivalent support software. For example, an AST service routine handles interrupts on OpenVMS systems; a signal handler routine handles interrupts on DIGITAL UNIX systems.

stack memory: Memory that is allocated from a thread's stack area at run time by code generated by the language compiler, generally when a routine is initially called. See also dynamic memory and static memory.

stacksize attribute: Attribute of a thread that specifies the minimum size (in bytes) of the memory required for its stack.

start routine: Routine in your program where a newly created thread begins executing.

static memory: Any variable that is permanently allocated at a particular address for the life of the program. See also dynamic memory and stack memory.

status exception: An exception whose identity is based on the status value it contains. See also exception and address exception.

synchronous signal: Signal that is the result of an event that occurs inside a process and is delivered synchronously with respect to that event. See also asynchronous signal.

system contention scope: Setting for the contention scope attribute of a thread. Specifies that a thread competes for processing resources with all other threads in the system. See also contention scope and process contention scope.

system granularity: Granularity provided by an operating system's run-time libraries, to provide a consistent and coherent environment for applications. See also actual granularity, granularity, and natural granularity.

terminating signal: Signal that results in the termination of the process by default. See also nonterminating signal.

thread: Single, sequential flow of control within a program. Within a single thread, there is a single point of execution.

thread attributes object: Object that allows you to specify values for thread attributes when you create a thread.

thread object: Data structure that describes a thread.

thread reentrant: Refers to a routine that functions normally despite being called simultaneously or sequentially in different threads.

thread safe: Refers to a routine that can be called simultaneously from multiple threads without risk of corruption. Refers to a library that typically consists of routines that do not themselves create or use threads but which can be called safely from applications that use threads.

thread-independent services: Routines in the DECthreads tis interface that support building thread-safe libraries.

thread-specific data: User-specified fields of arbitrary data that can be added to a thread's context.

time slicing: Mechanism that ensures that every thread is allowed time to execute by preempting running threads at fixed intervals.

tis condition variable: Condition variable object that can be created using DECthreads tis interface routines.

tis mutex: Mutex object that can be created using DECthreads tis interface routines.

two-level scheduling: Thread scheduling model that schedules user threads onto kernel execution contexts, just as the operating system schedules processes onto the processors of a multiprocessor machine.

upcall: Technique for the operating system kernel to inform DECthreads that a kernel execution context is available. When a kernel execution context becomes available, the DECthreads scheduler schedules the thread with highest scheduling precedence that is ready to run onto the available kernel execution context.

word tearing: Form of race condition in a multithreaded program where two or more threads independently read the same granule of memory, update different portions of that granule, then independently (that is, asynchronously) store their respective copies of that granule. Can occur due to programmer's inattention to granularity considerations.

	privacy and legal statement
6101PRO_033.HTML