Glossary

alert: See cancel.
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 cancellation request at any time (not only at cancellation 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.
atomic queue: DECthreads Library object that can be used to communicate information among threads or among routines in a single thread.
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, queue, or attributes object). This description consists of the individual attribute values that are used to create an object. See also attributes.
cancel: Mechanism by which one thread requests termination of another thread (or itself).
cancelable routine: Routine in which a cancel may be delivered.
cancellation point: DECthreads routine that, when called by a routine, can determine whether a cancel is pending for that routine, and if so, can deliver the cancel.
condition variable: Object that allows a thread to block its own execution until some shared data reaches a particular state.
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 "fast" 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.
exception: Object that describes an error condition.
exception scope: Block of code where exceptions are handled.
fast 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. "Fast" refers to a streamlined implementation that provides the best performance. See also mutex.
general cancelability: If enabled, allows a thread to receive a cancellation request at specific cancellation 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.
guard area: Area at the end of the thread stack that is inaccessible to the thread. This helps prevent or detect overflow of the thread's stack.
guardsize attribute: Minimum size (in bytes) of the guard area for the stack of a thread.
handle: Storage, similar to a pointer, that refers to a specific DECthreads object.
inherit scheduling attribute: Attribute 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.
lifetime: Length of time memory is allocated for a particular purpose.
multithreaded programming: Division of a program into multiple threads that execute concurrently.
mutex: Meaning 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 fast mutex, nonrecursive mutex, and recursive mutex.
mutex attributes object: Attribute that allows you to specify values for mutex attributes when you create a mutex.
mutex kind attribute: Attribute that specifies whether a mutex is fast, recursive, or nonrecursive.
nonrecursive mutex: Mutex that can be locked exactly once by a thread, like a fast mutex. If a thread tries to lock the mutex again without first unlocking it, the thread receives an error instead of deadlocking. See also mutex, fast mutex, and deadlock.
nonterminating signal: Signal that does not result in the termination of the process by default. See also terminating signal.
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.
queuesize attribute: Number of elements allowed on a queue. See also atomic queue.
race condition: Occurs when two or more threads perform an operation, and the result of the operation depends on unpredictable timing factors.
recursive mutex: Mutex that can be locked more than once by a given thread without causing a deadlock. The thread must call the cma_mutex_unlock or pthread_mutex_unlock routine the same number of times that it called the cma_mutex_lock or pthread_mutex_lock routine before another thread can lock the mutex. See also mutex and deadlock.
scheduling policy attribute: Attribute 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 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 UNIX systems.
stacksize attribute: Minimum size (in bytes) of the memory required for a thread's stack.
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.
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.
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.
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-reentrant: Routine that functions normally despite being called simultaneously or sequentially in different threads.
thread-safe: Routine that can be called simultaneously from multiple threads without risk of corruption.
thread-specific data: User-specified fields of arbitrary data that can be added to a thread's context.
timeslicing: Mechanism that ensures that every thread is allowed time to execute by preempting running threads at fixed intervals.