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
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 Threads
Library 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 Threads
Library run-time environment that causes it to produce a specially
formatted error message. Output of this message can be controlled using
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 cancelation) 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
Threads Library 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 the
Threads Library 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 a thread's
writable stack and the stack overflow warning area that is inaccessible
to the thread. If the thread attempts to access a memory location
within the guard area, a memory addressing violation occurs. See
also overflow warning area.
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
handle: Storage, similar to a pointer, that refers to
a specific Threads Library object.
inherit scheduling attribute: Attribute of a thread
that specifies whether a newly created thread inherits the scheduling
attributes (scheduling priority, policy and contention scope) 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
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
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 the Threads
Library, this kind of mutex offers the best performance. See
also mutex, errorcheck mutex, and recursive mutex.
overflow warning area: Area between the overflow end
of the thread's writable stack and the stack guard area. If the thread
attempts to access a memory location within the overflow warning area,
a stack overflow exception occurs. The program can catch this exception
and continue processing. See also guard area.
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
routine the same number of times that it called the
routine before another thread can lock the mutex. See also
deadlock, mutex, normal mutex, and errorcheck mutex.
reentrant: Refers to a routine that functions normally
despite being called simultaneously or sequentially in different
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 Threads Library scheduling algorithm that, in
combination, determine which thread will be allowed to run when a
scheduling decision is made. Scheduling decisions are made either 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 broadcast), or when a thread is blocked (for
example, when it attempts to lock a locked mutex or when it waits on a
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 Tru64 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.
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
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-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 Threads
Library tis interface that support building
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
tis condition variable: Condition variable object that
can be created using the Threads Library tis interface
tis mutex: Mutex object that can be created using the
Threads Library 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 the Threads Library that a kernel execution context is
available. When a kernel execution context becomes available, the
Threads Library scheduler schedules the thread with highest scheduling
precedence that is ready to run onto the available kernel execution
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.