source: rtems/doc/user/glossary.texi @ dafa5d88

@c
@c  COPYRIGHT (c) 1989-2011.
@c  On-Line Applications Research Corporation (OAR).
@c  All rights reserved.

@node Glossary, Command and Variable Index, Example Application, Top
@chapter Glossary

@table @dfn
@item active
A term used to describe an object
which has been created by an application.

@item aperiodic task
A task which must execute only at
irregular intervals and has only a soft deadline.

@item application
In this document, software which makes
use of RTEMS.

@item ASR
see Asynchronous Signal Routine.

@item asynchronous
Not related in order or timing to
other occurrences in the system.

@item Asynchronous Signal Routine
Similar to a hardware
interrupt except that it is associated with a task and is run in
the context of a task.  The directives provided by the signal
manager are used to service signals.

@item atomic operations
Atomic operations are defined in terms of @cite{ISO/IEC 9899:2011}.

@item awakened
A term used to describe a task that has
been unblocked and may be scheduled to the CPU.

@item big endian
A data representation scheme in which
the bytes composing a numeric value are arranged such that the
most significant byte is at the lowest address.

@item bit-mapped
A data encoding scheme in which each bit
in a variable is used to represent something different.  This
makes for compact data representation.

@item block
A physically contiguous area of memory.

@item blocked task
The task state entered by a task which has been previously started and cannot
continue execution until the reason for waiting has been satisfied.  Blocked
tasks are not an element of the set of ready tasks of a scheduler instance.

@item broadcast
To simultaneously send a message to a
logical set of destinations.

@item BSP
see Board Support Package.

@item Board Support Package
A collection of device
initialization and control routines specific to a particular
type of board or collection of boards.

@item buffer
A fixed length block of memory allocated
from a partition.

@item calling convention
The processor and compiler
dependent rules which define the mechanism used to invoke
subroutines in a high-level language.  These rules define the
passing of arguments, the call and return mechanism, and the
register set which must be preserved.

@item Central Processing Unit
This term is equivalent to
the terms processor and microprocessor.

@item chain
A data structure which allows for efficient
dynamic addition and removal of elements.  It differs from an
array in that it is not limited to a predefined size.

@item cluster
We have clustered scheduling in case the set of processors of a system is
partitioned into non-empty pairwise disjoint subsets.  These subsets are called
@dfn{clusters}.  Clusters with a cardinality of one are partitions.  Each
cluster is owned by exactly one scheduler instance.

@item coalesce
The process of merging adjacent holes into
a single larger hole.  Sometimes this process is referred to as
garbage collection.

@item Configuration Table
A table which contains
information used to tailor RTEMS for a particular application.

@item context
All of the processor registers and
operating system data structures associated with a task.

@item context switch
Alternate term for task switch.
Taking control of the processor from one task and transferring
it to another task.

@item control block
A data structure used by the
executive to define and control an object.

@item core
When used in this manual, this term refers to
the internal executive utility functions.  In the interest of
application portability, the core of the executive should not be
used directly by applications.

@item CPU
An acronym for Central Processing Unit.

@item critical section
A section of code which must be
executed indivisibly.

@item CRT
An acronym for Cathode Ray Tube.  Normally used
in reference to the man-machine interface.

@item deadline
A fixed time limit by which a task must
have completed a set of actions.  Beyond this point, the results
are of reduced value and may even be considered useless or
harmful.

@item device
A peripheral used by the application that
requires special operation software.  See also device driver.

@item device driver
Control software for special
peripheral devices used by the application.

@item directives
RTEMS' provided routines that provide
support mechanisms for real-time applications.

@item dispatch
The act of loading a task's context onto
the CPU and transferring control of the CPU to that task.

@item dormant
The state entered by a task after it is
created and before it has been started.

@item Device Driver Table
A table which contains the
entry points for each of the configured device drivers.

@item dual-ported
A term used to describe memory which
can be accessed at two different addresses.

@item embedded
An application that is delivered as a
hidden part of a larger system.  For example, the software in a
fuel-injection control system is an embedded application found
in many late-model automobiles.

@item envelope
A buffer provided by the MPCI layer to
RTEMS which is used to pass messages between nodes in a
multiprocessor system.  It typically contains routing
information needed by the MPCI.  The contents of an envelope are
referred to as a packet.

@item entry point
The address at which a function or task
begins to execute.  In C, the entry point of a function is the
function's name.

@item events
A method for task communication and
synchronization. The directives provided by the event manager
are used to service events.

@item exception
A synonym for interrupt.

@item executing task
The task state entered by a task after it has been given control of the
processor.  On SMP configurations a task may be registered as executing on more
than one processor for short time frames during task migration.  Blocked tasks
can be executing until they issue a thread dispatch.

@item executive
In this document, this term is used to
referred to RTEMS.  Commonly, an executive is a small real-time
operating system used in embedded systems.

@item exported
An object known by all nodes in a
multiprocessor system.  An object created with the GLOBAL
attribute will be exported.

@item external address
The address used to access
dual-ported memory by all the nodes in a system which do not own
the memory.

@item FIFO
An acronym for First In First Out.

@item First In First Out
A discipline for manipulating entries in a data structure.

@item floating point coprocessor
A component used in
computer systems to enhance performance in mathematically
intensive situations.  It is typically viewed as a logical
extension of the primary processor.

@item freed
A resource that has been released by the
application to RTEMS.

@item Giant lock
The @dfn{Giant lock} is a recursive SMP lock protecting most parts of the
operating system state.  Virtually every operating system service must acquire
and release the Giant lock during its operation.

@item global
An object that has been created with the
GLOBAL attribute and exported to all nodes in a multiprocessor
system.

@item handler
The equivalent of a manager, except that it
is internal to RTEMS and forms part of the core.  A handler is a
collection of routines which provide a related set of functions.
For example, there is a handler used by RTEMS to manage all
objects.

@item hard real-time system
A real-time system in which a
missed deadline causes the worked performed to have no value or
to result in a catastrophic effect on the integrity of the
system.

@item heap
A data structure used to dynamically allocate
and deallocate variable sized blocks of memory.

@item heir task
A task is an @dfn{heir} if it is registered as an heir in a processor of the
system.  A task can be the heir on at most one processor in the system.  In
case the executing and heir tasks differ on a processor and a thread dispatch
is marked as necessary, then the next thread dispatch will make the heir task
the executing task.

@item heterogeneous
A multiprocessor computer system composed of dissimilar processors.

@item homogeneous
A multiprocessor computer system composed of a single type of processor.

@item ID
An RTEMS assigned identification tag used to
access an active object.

@item IDLE task
A special low priority task which assumes
control of the CPU when no other task is able to execute.

@item interface
A specification of the methodology used
to connect multiple independent subsystems.

@item internal address
The address used to access
dual-ported memory by the node which owns the memory.

@item interrupt
A hardware facility that causes the CPU
to suspend execution, save its status, and transfer control to a
specific location.

@item interrupt level
A mask used to by the CPU to
determine which pending interrupts should be serviced.  If a
pending interrupt is below the current interrupt level, then the
CPU does not recognize that interrupt.

@item Interrupt Service Routine
An ISR is invoked by the
CPU to process a pending interrupt.

@item I/O
An acronym for Input/Output.

@item ISR
An acronym for Interrupt Service Routine.

@item kernel
In this document, this term is used as a
synonym for executive.

@item list
A data structure which allows for dynamic
addition and removal of entries.  It is not statically limited
to a particular size.

@item little endian
A data representation scheme in which
the bytes composing a numeric value are arranged such that the
least significant byte is at the lowest address.

@item local
An object which was created with the LOCAL
attribute and is accessible only on the node it was created and
resides upon.  In a single processor configuration, all objects
are local.

@item local operation
The manipulation of an object which
resides on the same node as the calling task.

@item logical address
An address used by an application.
In a system without memory management, logical addresses will
equal physical addresses.

@item loosely-coupled
A multiprocessor configuration
where shared memory is not used for communication.

@item major number
The index of a device driver in the
Device Driver Table.

@item manager
A group of related RTEMS' directives which
provide access and control over resources.

@item memory pool
Used interchangeably with heap.

@item message
A sixteen byte entity used to communicate
between tasks.  Messages are sent to message queues and stored
in message buffers.

@item message buffer
A block of memory used to store
messages.

@item message queue
An RTEMS object used to synchronize
and communicate between tasks by transporting messages between
sending and receiving tasks.

@item Message Queue Control Block
A data structure associated with each message queue used by RTEMS
to manage that message queue.

@item minor number
A numeric value passed to a device
driver, the exact usage of which is driver dependent.

@item mode
An entry in a task's control block that is
used to determine if the task allows preemption, timeslicing,
processing of signals, and the interrupt disable level used by
the task.

@item MPCI
An acronym for Multiprocessor Communications
Interface Layer.

@item multiprocessing
The simultaneous execution of two
or more processes by a multiple processor computer system.

@item multiprocessor
A computer with multiple CPUs
available for executing applications.

@item Multiprocessor Communications Interface Layer
A set
of user-provided routines which enable the nodes in a
multiprocessor system to communicate with one another.

@item Multiprocessor Configuration Table
The data structure defining the characteristics of the multiprocessor
target system with which RTEMS will communicate.

@item multitasking
The alternation of execution amongst a
group of processes on a single CPU.  A scheduling algorithm is
used to determine which process executes at which time.

@item mutual exclusion
A term used to describe the act of
preventing other tasks from accessing a resource simultaneously.

@item nested
A term used to describe an ASR that occurs
during another ASR or an ISR that occurs during another ISR.

@item node
A term used to reference a processor running
RTEMS in a multiprocessor system.

@item non-existent
The state occupied by an uncreated or
deleted task.

@item numeric coprocessor
A component used in computer
systems to enhance performance in mathematically intensive
situations.  It is typically viewed as a logical extension of
the primary processor.

@item object
In this document, this term is used to refer
collectively to tasks, timers, message queues, partitions,
regions, semaphores, ports, and rate monotonic periods.  All
RTEMS objects have IDs and user-assigned names.

@item object-oriented
A term used to describe systems
with common mechanisms for utilizing a variety of entities.
Object-oriented systems shield the application from
implementation details.

@item operating system
The software which controls all
the computer's resources and provides the base upon which
application programs can be written.

@item overhead
The portion of the CPUs processing power
consumed by the operating system.

@item packet
A buffer which contains the messages passed
between nodes in a multiprocessor system.  A packet is the
contents of an envelope.

@item partition
An RTEMS object which is used to allocate
and deallocate fixed size blocks of memory from an dynamically
specified area of memory.

@item partition
Clusters with a cardinality of one are @dfn{partitions}.

@item Partition Control Block
A data structure associated
with each partition used by RTEMS to manage that partition.

@item pending
A term used to describe a task blocked
waiting for an event, message, semaphore, or signal.

@item periodic task
A task which must execute at regular
intervals and comply with a hard deadline.

@item physical address
The actual hardware address of a
resource.

@item poll
A mechanism used to determine if an event has
occurred by periodically checking for a particular status.
Typical events include arrival of data, completion of an action,
and errors.

@item pool
A collection from which resources are
allocated.

@item portability
A term used to describe the ease with
which software can be rehosted on another computer.

@item posting
The act of sending an event, message,
semaphore, or signal to a task.

@item preempt
The act of forcing a task to relinquish the
processor and dispatching to another task.

@item priority
A mechanism used to represent the relative
importance of an element in a set of items.  RTEMS uses priority
to determine which task should execute.

@item priority boosting
A simple approach to extend the priority inheritance protocol for clustered
scheduling is @dfn{priority boosting}.  In case a mutex is owned by a task of
another cluster, then the priority of the owner task is raised to an
artificially high priority, the pseudo-interrupt priority.

@item priority inheritance
An algorithm that calls for
the lower priority task holding a resource to have its priority
increased to that of the highest priority task blocked waiting
for that resource.  This avoids the problem of priority
inversion.

@item priority inversion
A form of indefinite
postponement which occurs when a high priority tasks requests
access to shared resource currently allocated to low priority
task.  The high priority task must block until the low priority
task releases the resource.

@item processor utilization
The percentage of processor
time used by a task or a set of tasks.

@item proxy
An RTEMS control structure used to represent,
on a remote node, a task which must block as part of a remote
operation.

@item Proxy Control Block
A data structure associated
with each proxy used by RTEMS to manage that proxy.

@item PTCB
An acronym for Partition Control Block.

@item PXCB
An acronym for Proxy Control Block.

@item quantum
The application defined unit of time in
which the processor is allocated.

@item queue
Alternate term for message queue.

@item QCB
An acronym for Message Queue Control Block.

@item ready task
A task occupies this state when it is available to be given control of a
processor.  A ready task has no processor assigned.  The scheduler decided that
other tasks are currently more important.  A task that is ready to execute and
has a processor assigned is called scheduled.

@item real-time
A term used to describe systems which are
characterized by requiring deterministic response times to
external stimuli.  The external stimuli require that the
response occur at a precise time or the response is incorrect.

@item reentrant
A term used to describe routines which do
not modify themselves or global variables.

@item region
An RTEMS object which is used to allocate
and deallocate variable size blocks of memory from a dynamically
specified area of memory.

@item Region Control Block
A data structure associated
with each region used by RTEMS to manage that region.

@item registers
Registers are locations physically
located within a component, typically used for device control or
general purpose storage.

@item remote
Any object that does not reside on the local
node.

@item remote operation
The manipulation of an object
which does not reside on the same node as the calling task.

@item return code
Also known as error code or return
value.

@item resource
A hardware or software entity to which
access must be controlled.

@item resume
Removing a task from the suspend state.  If
the task's state is ready following a call to the 
@code{@value{DIRPREFIX}task_resume}
directive, then the task is available for scheduling.

@item return code
A value returned by RTEMS directives to
indicate the completion status of the directive.

@item RNCB
An acronym for Region Control Block.

@item round-robin
A task scheduling discipline in which
tasks of equal priority are executed in the order in which they
are made ready.

@item RS-232
A standard for serial communications.

@item running
The state of a rate monotonic timer while
it is being used to delineate a period.  The timer exits this
state by either expiring or being canceled.

@item schedulable
A set of tasks which can be guaranteed
to meet their deadlines based upon a specific scheduling
algorithm.

@item schedule
The process of choosing which task should
next enter the executing state.

@item scheduled task
A task is @dfn{scheduled} if it is allowed to execute and has a processor
assigned.  Such a task executes currently on a processor or is about to start
execution.  A task about to start execution it is an heir task on exactly one
processor in the system.

@item scheduler
A @dfn{scheduler} or @dfn{scheduling algorithm} allocates processors to a
subset of its set of ready tasks.  So it manages access to the processor
resource.  Various algorithms exist to choose the tasks allowed to use a
processor out of the set of ready tasks.  One method is to assign each task a
priority number and assign the tasks with the lowest priority number to one
processor of the set of processors owned by a scheduler instance.

@item scheduler instance
A @dfn{scheduler instance} is a scheduling algorithm with a corresponding
context to store its internal state.  Each processor in the system is owned by
at most one scheduler instance.  The processor to scheduler instance assignment
is determined at application configuration time.  @xref{Configuring a System
Configuring Clustered Schedulers}.

@item segments
Variable sized memory blocks allocated
from a region.

@item semaphore
An RTEMS object which is used to
synchronize tasks and provide mutually exclusive access to
resources.

@item Semaphore Control Block
A data structure associated
with each semaphore used by RTEMS to manage that semaphore.

@item shared memory
Memory which is accessible by
multiple nodes in a multiprocessor system.

@item signal
An RTEMS provided mechanism to communicate
asynchronously with a task.  Upon reception of a signal, the ASR
of the receiving task will be invoked.

@item signal set
A thirty-two bit entity which is used to
represent a task's collection of pending signals and the signals
sent to a task.

@item SMCB
An acronym for Semaphore Control Block.

@item SMP locks
The @dfn{SMP locks} ensure mutual exclusion on the lowest level and are a
replacement for the sections of disabled interrupts.  Interrupts are usually
disabled while holding an SMP lock.  They are implemented using atomic
operations.  Currently a ticket lock is used in RTEMS.

@item SMP barriers
The @dfn{SMP barriers} ensure that a defined set of independent threads of
execution on a set of processors reaches a common synchronization point in
time.  They are implemented using atomic operations.  Currently a sense barrier
is used in RTEMS.

@item soft real-time system
A real-time system in which a
missed deadline does not compromise the integrity of the system.

@item sporadic task
A task which executes at irregular
intervals and must comply with a hard deadline.  A minimum
period of time between successive iterations of the task can be
guaranteed.

@item stack
A data structure that is managed using a Last
In First Out (LIFO) discipline.  Each task has a stack
associated with it which is  used to store return information
and local variables.

@item status code
Also known as error code or return
value.

@item suspend
A term used to describe a task that is not
competing for the CPU because it has had a 
@code{@value{DIRPREFIX}task_suspend} directive.

@item synchronous
Related in order or timing to other
occurrences in the system.

@item system call
In this document, this is used as an
alternate term for directive.

@item target
The system on which the application will
ultimately execute.

@item task
A logically complete thread of execution.  It consists normally of a set of
registers and a stack.  The terms @dfn{task} and @dfn{thread} are synonym in
RTEMS.  The scheduler assigns processors to a subset of the ready tasks.

@item Task Control Block
A data structure associated with
each task used by RTEMS to manage that task.

@item task migration
@dfn{Task migration} happens in case a task stops execution on one processor
and resumes execution on another processor.

@item task processor affinity
The set of processors on which a task is allowed to execute.

@item task switch
Alternate terminology for context
switch.  Taking control of the processor from one task and given
to another.

@item TCB
An acronym for Task Control Block.

@item thread dispatch
The @dfn{thread dispatch} transfers control of the processor from the currently
executing thread to the heir thread of the processor.

@item tick
The basic unit of time used by RTEMS.  It is a
user-configurable number of microseconds.  The current tick
expires when the @code{@value{DIRPREFIX}clock_tick}
directive is invoked.

@item tightly-coupled
A multiprocessor configuration
system which communicates via shared memory.

@item timeout
An argument provided to a number of
directives which determines the maximum length of time an
application task is willing to wait to acquire the resource if
it is not immediately available.

@item timer
An RTEMS object used to invoke subprograms at
a later time.

@item Timer Control Block
A data structure associated
with each timer used by RTEMS to manage that timer.

@item timeslicing
A task scheduling discipline in which
tasks of equal priority are executed for a specific period of
time before being preempted by another task.

@item timeslice
The application defined unit of time in
which the processor is allocated.

@item TMCB
An acronym for Timer Control Block.

@item transient overload
A temporary rise in system
activity which may cause deadlines to be missed.  Rate Monotonic
Scheduling can be used to determine if all deadlines will be met
under transient overload.

@item user extensions
Software routines provided by the
application to enhance the functionality of RTEMS.

@item User Extension Table
A table which contains the
entry points for each user extensions.

@item User Initialization Tasks Table
A table which
contains the information needed to create and start each of the
user initialization tasks.

@item user-provided
Alternate term for user-supplied.
This term is used to designate any software routines which must
be written by the application designer.

@item user-supplied
Alternate term for user-provided.
This term is used to designate any software routines which must
be written by the application designer.

@item vector
Memory pointers used by the processor to
fetch the address of routines which will handle various
exceptions and interrupts.

@item wait queue
The list of tasks blocked pending the
release of a particular resource.  Message queues, regions, and
semaphores have a wait queue associated with them.

@item yield
When a task voluntarily releases control of the processor.

@end table