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
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
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
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
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
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
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 overflow end of the thread
stack that is inaccessible to the thread. This helps prevent or detect
overflow of the thread's stack.
guardsize attribute: Attribute of a thread that
specifies the minimum size (in bytes) of the guard area for a thread's
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
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.
nonterminating signal: Signal that does not result in
the termination of the process by default. See also
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
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
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
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
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
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
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.
terminating signal: Signal that results in the
termination of the process by default. See also nonterminating
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
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-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
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
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.