Changeset 3e005fe in rtems-docs


Ignore:
Timestamp:
02/02/17 10:22:59 (7 years ago)
Author:
Sebastian Huber <sebastian.huber@…>
Branches:
5, master
Children:
785c02f
Parents:
2e0a2a0
Message:

c-user: Use sphinx glossary support

Terms can be referenced via :term:XYZ.

Location:
c-user
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • c-user/glossary.rst

    r2e0a2a0 r3e005fe  
    44********
    55
    6 :dfn:`active`
    7     A term used to describe an object which has been created by an application.
    8 
    9 :dfn:`aperiodic task`
    10     A task which must execute only at irregular intervals and has only a soft
    11     deadline.
    12 
    13 :dfn:`application`
    14     In this document, software which makes use of RTEMS.
    15 
    16 :dfn:`ASR`
    17     see Asynchronous Signal Routine.
    18 
    19 :dfn:`asynchronous`
    20     Not related in order or timing to other occurrences in the system.
    21 
    22 :dfn:`Asynchronous Signal Routine`
    23     Similar to a hardware interrupt except that it is associated with a task
    24     and is run in the context of a task.  The directives provided by the signal
    25     manager are used to service signals.
    26 
    27 :dfn:`atomic operations`
    28     Atomic operations are defined in terms of :ref:`C11 <C11>`.
    29 
    30 :dfn:`awakened`
    31     A term used to describe a task that has been unblocked and may be scheduled
    32     to the CPU.
    33 
    34 :dfn:`big endian`
    35     A data representation scheme in which the bytes composing a numeric value
    36     are arranged such that the most significant byte is at the lowest address.
    37 
    38 :dfn:`bit-mapped`
    39     A data encoding scheme in which each bit in a variable is used to represent
    40     something different.  This makes for compact data representation.
    41 
    42 :dfn:`block`
    43     A physically contiguous area of memory.
    44 
    45 :dfn:`blocked task`
    46     The task state entered by a task which has been previously started and
    47     cannot continue execution until the reason for waiting has been satisfied.
    48     Blocked tasks are not an element of the set of ready tasks of a scheduler
    49     instance.
    50 
    51 :dfn:`broadcast`
    52     To simultaneously send a message to a logical set of destinations.
    53 
    54 :dfn:`BSP`
    55     see Board Support Package.
    56 
    57 :dfn:`Board Support Package`
    58     A collection of device initialization and control routines specific to a
    59     particular type of board or collection of boards.
    60 
    61 :dfn:`buffer`
    62     A fixed length block of memory allocated from a partition.
    63 
    64 .. _C11:
    65 
    66 :dfn:`C11`
    67     The standard ISO/IEC 9899:2011.
    68 
    69 .. _C++11:
    70 
    71 :dfn:`C++11`
    72     The standard ISO/IEC 14882:2011.
    73 
    74 :dfn:`calling convention`
    75     The processor and compiler dependent rules which define the mechanism used
    76     to invoke subroutines in a high-level language.  These rules define the
    77     passing of arguments, the call and return mechanism, and the register set
    78     which must be preserved.
    79 
    80 :dfn:`Central Processing Unit`
    81     This term is equivalent to the terms processor and microprocessor.
    82 
    83 :dfn:`chain`
    84     A data structure which allows for efficient dynamic addition and removal of
    85     elements.  It differs from an array in that it is not limited to a
    86     predefined size.
    87 
    88 :dfn:`cluster`
    89     We have clustered scheduling in case the set of processors of a system is
    90     partitioned into non-empty pairwise disjoint subsets.  These subsets are
    91     called:dfn:`clusters`.  Clusters with a cardinality of one are partitions.
    92     Each cluster is owned by exactly one scheduler instance.
    93 
    94 :dfn:`coalesce`
    95     The process of merging adjacent holes into a single larger hole.  Sometimes
    96     this process is referred to as garbage collection.
    97 
    98 :dfn:`Configuration Table`
    99     A table which contains information used to tailor RTEMS for a particular
    100     application.
    101 
    102 :dfn:`context`
    103     All of the processor registers and operating system data structures
    104     associated with a task.
    105 
    106 :dfn:`context switch`
    107     Alternate term for task switch.  Taking control of the processor from one
    108     task and transferring it to another task.
    109 
    110 :dfn:`control block`
    111     A data structure used by the executive to define and control an object.
    112 
    113 :dfn:`core`
    114     When used in this manual, this term refers to the internal executive
    115     utility functions.  In the interest of application portability, the core of
    116     the executive should not be used directly by applications.
    117 
    118 :dfn:`CPU`
    119     An acronym for Central Processing Unit.
    120 
    121 :dfn:`critical section`
    122     A section of code which must be executed indivisibly.
    123 
    124 :dfn:`CRT`
    125     An acronym for Cathode Ray Tube.  Normally used in reference to the
    126     man-machine interface.
    127 
    128 :dfn:`deadline`
    129     A fixed time limit by which a task must have completed a set of actions.
    130     Beyond this point, the results are of reduced value and may even be
    131     considered useless or harmful.
    132 
    133 :dfn:`device`
    134     A peripheral used by the application that requires special operation
    135     software.  See also device driver.
    136 
    137 :dfn:`device driver`
    138     Control software for special peripheral devices used by the application.
    139 
    140 :dfn:`directives`
    141     RTEMS' provided routines that provide support mechanisms for real-time
    142     applications.
    143 
    144 :dfn:`dispatch`
    145     The act of loading a task's context onto the CPU and transferring control
    146     of the CPU to that task.
    147 
    148 :dfn:`dormant`
    149     The state entered by a task after it is created and before it has been
    150     started.
    151 
    152 :dfn:`Device Driver Table`
    153     A table which contains the entry points for each of the configured device
    154     drivers.
    155 
    156 :dfn:`dual-ported`
    157     A term used to describe memory which can be accessed at two different
    158     addresses.
    159 
    160 :dfn:`embedded`
    161     An application that is delivered as a hidden part of a larger system.  For
    162     example, the software in a fuel-injection control system is an embedded
    163     application found in many late-model automobiles.
    164 
    165 :dfn:`envelope`
    166     A buffer provided by the MPCI layer to RTEMS which is used to pass messages
    167     between nodes in a multiprocessor system.  It typically contains routing
    168     information needed by the MPCI.  The contents of an envelope are referred
    169     to as a packet.
    170 
    171 :dfn:`entry point`
    172     The address at which a function or task begins to execute.  In C, the entry
    173     point of a function is the function's name.
    174 
    175 :dfn:`events`
    176     A method for task communication and synchronization. The directives
    177     provided by the event manager are used to service events.
    178 
    179 :dfn:`exception`
    180     A synonym for interrupt.
    181 
    182 :dfn:`executing task`
    183     The task state entered by a task after it has been given control of the
    184     processor.  In SMP configurations, a task may be registered as executing on
    185     more than one processor for short time frames during task migration.
    186     Blocked tasks can be executing until they issue a thread dispatch.
    187 
    188 :dfn:`executive`
    189     In this document, this term is used to referred to RTEMS.  Commonly, an
    190     executive is a small real-time operating system used in embedded systems.
    191 
    192 :dfn:`exported`
    193     An object known by all nodes in a multiprocessor system.  An object created
    194     with the GLOBAL attribute will be exported.
    195 
    196 :dfn:`external address`
    197     The address used to access dual-ported memory by all the nodes in a system
    198     which do not own the memory.
    199 
    200 :dfn:`FIFO`
    201     An acronym for First In First Out.
    202 
    203 :dfn:`First In First Out`
    204     A discipline for manipulating entries in a data structure.
    205 
    206 :dfn:`floating point coprocessor`
    207     A component used in computer systems to enhance performance in
    208     mathematically intensive situations.  It is typically viewed as a logical
    209     extension of the primary processor.
    210 
    211 :dfn:`freed`
    212     A resource that has been released by the application to RTEMS.
    213 
    214 :dfn:`global`
    215     An object that has been created with the GLOBAL attribute and exported to
    216     all nodes in a multiprocessor system.
    217 
    218 :dfn:`handler`
    219     The equivalent of a manager, except that it is internal to RTEMS and forms
    220     part of the core.  A handler is a collection of routines which provide a
    221     related set of functions.  For example, there is a handler used by RTEMS to
    222     manage all objects.
    223 
    224 :dfn:`hard real-time system`
    225     A real-time system in which a missed deadline causes the worked performed
    226     to have no value or to result in a catastrophic effect on the integrity of
    227     the system.
    228 
    229 :dfn:`heap`
    230     A data structure used to dynamically allocate and deallocate variable sized
    231     blocks of memory.
    232 
    233 :dfn:`heir task`
    234     A task is an :dfn:`heir` if it is registered as an heir in a processor of
    235     the system.  A task can be the heir on at most one processor in the system.
    236     In case the executing and heir tasks differ on a processor and a thread
    237     dispatch is marked as necessary, then the next thread dispatch will make
    238     the heir task the executing task.
    239 
    240 :dfn:`heterogeneous`
    241     A multiprocessor computer system composed of dissimilar processors.
    242 
    243 :dfn:`homogeneous`
    244     A multiprocessor computer system composed of a single type of processor.
    245 
    246 :dfn:`ID`
    247     An RTEMS assigned identification tag used to access an active object.
    248 
    249 :dfn:`IDLE task`
    250     A special low priority task which assumes control of the CPU when no other
    251     task is able to execute.
    252 
    253 :dfn:`interface`
    254     A specification of the methodology used to connect multiple independent
    255     subsystems.
    256 
    257 :dfn:`internal address`
    258     The address used to access dual-ported memory by the node which owns the
    259     memory.
    260 
    261 :dfn:`interrupt`
    262     A hardware facility that causes the CPU to suspend execution, save its
    263     status, and transfer control to a specific location.
    264 
    265 :dfn:`interrupt level`
    266     A mask used to by the CPU to determine which pending interrupts should be
    267     serviced.  If a pending interrupt is below the current interrupt level,
    268     then the CPU does not recognize that interrupt.
    269 
    270 :dfn:`Interrupt Service Routine`
    271     An ISR is invoked by the CPU to process a pending interrupt.
    272 
    273 :dfn:`I/O`
    274     An acronym for Input/Output.
    275 
    276 :dfn:`ISR`
    277     An acronym for Interrupt Service Routine.
    278 
    279 :dfn:`kernel`
    280     In this document, this term is used as a synonym for executive.
    281 
    282 :dfn:`list`
    283     A data structure which allows for dynamic addition and removal of entries.
    284     It is not statically limited to a particular size.
    285 
    286 :dfn:`little endian`
    287     A data representation scheme in which the bytes composing a numeric value
    288     are arranged such that the least significant byte is at the lowest address.
    289 
    290 :dfn:`local`
    291     An object which was created with the LOCAL attribute and is accessible only
    292     on the node it was created and resides upon.  In a single processor
    293     configuration, all objects are local.
    294 
    295 :dfn:`local operation`
    296     The manipulation of an object which resides on the same node as the calling
    297     task.
    298 
    299 :dfn:`logical address`
    300     An address used by an application.  In a system without memory management,
    301     logical addresses will equal physical addresses.
    302 
    303 :dfn:`loosely-coupled`
    304     A multiprocessor configuration where shared memory is not used for
    305     communication.
    306 
    307 :dfn:`major number`
    308     The index of a device driver in the Device Driver Table.
    309 
    310 :dfn:`manager`
    311     A group of related RTEMS' directives which provide access and control over
    312     resources.
    313 
    314 :dfn:`memory pool`
    315     Used interchangeably with heap.
    316 
    317 :dfn:`message`
    318     A sixteen byte entity used to communicate between tasks.  Messages are sent
    319     to message queues and stored in message buffers.
    320 
    321 :dfn:`message buffer`
    322     A block of memory used to store messages.
    323 
    324 :dfn:`message queue`
    325     An RTEMS object used to synchronize and communicate between tasks by
    326     transporting messages between sending and receiving tasks.
    327 
    328 :dfn:`Message Queue Control Block`
    329     A data structure associated with each message queue used by RTEMS to manage
    330     that message queue.
    331 
    332 :dfn:`minor number`
    333     A numeric value passed to a device driver, the exact usage of which is
    334     driver dependent.
    335 
    336 :dfn:`mode`
    337     An entry in a task's control block that is used to determine if the task
    338     allows preemption, timeslicing, processing of signals, and the interrupt
    339     disable level used by the task.
    340 
    341 :dfn:`MPCI`
    342     An acronym for Multiprocessor Communications Interface Layer.
    343 
    344 :dfn:`multiprocessing`
    345     The simultaneous execution of two or more processes by a multiple processor
    346     computer system.
    347 
    348 :dfn:`multiprocessor`
    349     A computer with multiple CPUs available for executing applications.
    350 
    351 :dfn:`Multiprocessor Communications Interface Layer`
    352     A set of user-provided routines which enable the nodes in a multiprocessor
    353     system to communicate with one another.
    354 
    355 :dfn:`Multiprocessor Configuration Table`
    356     The data structure defining the characteristics of the multiprocessor
    357     target system with which RTEMS will communicate.
    358 
    359 :dfn:`multitasking`
    360     The alternation of execution amongst a group of processes on a single CPU.
    361     A scheduling algorithm is used to determine which process executes at which
    362     time.
    363 
    364 :dfn:`mutual exclusion`
    365     A term used to describe the act of preventing other tasks from accessing a
    366     resource simultaneously.
    367 
    368 :dfn:`nested`
    369     A term used to describe an ASR that occurs during another ASR or an ISR
    370     that occurs during another ISR.
    371 
    372 :dfn:`node`
    373     A term used to reference a processor running RTEMS in a multiprocessor
    374     system.
    375 
    376 :dfn:`non-existent`
    377     The state occupied by an uncreated or deleted task.
    378 
    379 :dfn:`numeric coprocessor`
    380     A component used in computer systems to enhance performance in
    381     mathematically intensive situations.  It is typically viewed as a logical
    382     extension of the primary processor.
    383 
    384 :dfn:`object`
    385     In this document, this term is used to refer collectively to tasks, timers,
    386     message queues, partitions, regions, semaphores, ports, and rate monotonic
    387     periods.  All RTEMS objects have IDs and user-assigned names.
    388 
    389 :dfn:`object-oriented`
    390     A term used to describe systems with common mechanisms for utilizing a
    391     variety of entities.  Object-oriented systems shield the application from
    392     implementation details.
    393 
    394 :dfn:`operating system`
    395     The software which controls all the computer's resources and provides the
    396     base upon which application programs can be written.
    397 
    398 :dfn:`overhead`
    399     The portion of the CPUs processing power consumed by the operating system.
    400 
    401 :dfn:`packet`
    402     A buffer which contains the messages passed between nodes in a
    403     multiprocessor system.  A packet is the contents of an envelope.
    404 
    405 :dfn:`partition`
    406     An RTEMS object which is used to allocate and deallocate fixed size blocks
    407     of memory from an dynamically specified area of memory.
    408 
    409 :dfn:`partition`
    410     Clusters with a cardinality of one are :dfn:`partitions`.
    411 
    412 :dfn:`Partition Control Block`
    413     A data structure associated with each partition used by RTEMS to manage
    414     that partition.
    415 
    416 :dfn:`pending`
    417     A term used to describe a task blocked waiting for an event, message,
    418     semaphore, or signal.
    419 
    420 :dfn:`periodic task`
    421     A task which must execute at regular intervals and comply with a hard
    422     deadline.
    423 
    424 :dfn:`physical address`
    425     The actual hardware address of a resource.
    426 
    427 :dfn:`poll`
    428     A mechanism used to determine if an event has occurred by periodically
    429     checking for a particular status.  Typical events include arrival of data,
    430     completion of an action, and errors.
    431 
    432 :dfn:`pool`
    433     A collection from which resources are allocated.
    434 
    435 :dfn:`portability`
    436     A term used to describe the ease with which software can be rehosted on
    437     another computer.
    438 
    439 :dfn:`posting`
    440     The act of sending an event, message, semaphore, or signal to a task.
    441 
    442 :dfn:`preempt`
    443     The act of forcing a task to relinquish the processor and dispatching to
    444     another task.
    445 
    446 :dfn:`priority`
    447     A mechanism used to represent the relative importance of an element in a
    448     set of items.  RTEMS uses priority to determine which task should execute.
    449 
    450 :dfn:`priority boosting`
    451     A simple approach to extend the priority inheritance protocol for clustered
    452     scheduling is :dfn:`priority boosting`.  In case a mutex is owned by a task
    453     of another cluster, then the priority of the owner task is raised to an
    454     artificially high priority, the pseudo-interrupt priority.
    455 
    456 :dfn:`priority inheritance`
    457     An algorithm that calls for the lower priority task holding a resource to
    458     have its priority increased to that of the highest priority task blocked
    459     waiting for that resource.  This avoids the problem of priority inversion.
    460 
    461 :dfn:`priority inversion`
    462     A form of indefinite postponement which occurs when a high priority tasks
    463     requests access to shared resource currently allocated to low priority
    464     task.  The high priority task must block until the low priority task
    465     releases the resource.
    466 
    467 :dfn:`processor utilization`
    468     The percentage of processor time used by a task or a set of tasks.
    469 
    470 :dfn:`proxy`
    471     An RTEMS control structure used to represent, on a remote node, a task
    472     which must block as part of a remote operation.
    473 
    474 :dfn:`Proxy Control Block`
    475     A data structure associated with each proxy used by RTEMS to manage that
    476     proxy.
    477 
    478 :dfn:`PTCB`
    479     An acronym for Partition Control Block.
    480 
    481 :dfn:`PXCB`
    482     An acronym for Proxy Control Block.
    483 
    484 :dfn:`quantum`
    485     The application defined unit of time in which the processor is allocated.
    486 
    487 :dfn:`queue`
    488     Alternate term for message queue.
    489 
    490 :dfn:`QCB`
    491     An acronym for Message Queue Control Block.
    492 
    493 :dfn:`ready task`
    494     A task occupies this state when it is available to be given control of a
    495     processor.  A ready task has no processor assigned.  The scheduler decided
    496     that other tasks are currently more important.  A task that is ready to
    497     execute and has a processor assigned is called scheduled.
    498 
    499 :dfn:`real-time`
    500     A term used to describe systems which are characterized by requiring
    501     deterministic response times to external stimuli.  The external stimuli
    502     require that the response occur at a precise time or the response is
    503     incorrect.
    504 
    505 :dfn:`reentrant`
    506     A term used to describe routines which do not modify themselves or global
    507     variables.
    508 
    509 :dfn:`region`
    510     An RTEMS object which is used to allocate and deallocate variable size
    511     blocks of memory from a dynamically specified area of memory.
    512 
    513 :dfn:`Region Control Block`
    514     A data structure associated with each region used by RTEMS to manage that
    515     region.
    516 
    517 :dfn:`registers`
    518     Registers are locations physically located within a component, typically
    519     used for device control or general purpose storage.
    520 
    521 :dfn:`remote`
    522     Any object that does not reside on the local node.
    523 
    524 :dfn:`remote operation`
    525     The manipulation of an object which does not reside on the same node as the
    526     calling task.
    527 
    528 :dfn:`return code`
    529     Also known as error code or return value.
    530 
    531 :dfn:`resource`
    532     A hardware or software entity to which access must be controlled.
    533 
    534 :dfn:`resume`
    535     Removing a task from the suspend state.  If the task's state is ready
    536     following a call to the ``rtems_task_resume`` directive, then the task is
    537     available for scheduling.
    538 
    539 :dfn:`return code`
    540     A value returned by RTEMS directives to indicate the completion status of
    541     the directive.
    542 
    543 :dfn:`RNCB`
    544     An acronym for Region Control Block.
    545 
    546 :dfn:`round-robin`
    547     A task scheduling discipline in which tasks of equal priority are executed
    548     in the order in which they are made ready.
    549 
    550 :dfn:`RS-232`
    551     A standard for serial communications.
    552 
    553 :dfn:`running`
    554     The state of a rate monotonic timer while it is being used to delineate a
    555     period.  The timer exits this state by either expiring or being canceled.
    556 
    557 :dfn:`schedulable`
    558     A set of tasks which can be guaranteed to meet their deadlines based upon a
    559     specific scheduling algorithm.
    560 
    561 :dfn:`schedule`
    562     The process of choosing which task should next enter the executing state.
    563 
    564 :dfn:`scheduled task`
    565     A task is :dfn:`scheduled` if it is allowed to execute and has a processor
    566     assigned.  Such a task executes currently on a processor or is about to
    567     start execution.  A task about to start execution it is an heir task on
    568     exactly one processor in the system.
    569 
    570 :dfn:`scheduler`
    571     A :dfn:`scheduler` or :dfn:`scheduling algorithm` allocates processors to a
    572     subset of its set of ready tasks.  So it manages access to the processor
    573     resource.  Various algorithms exist to choose the tasks allowed to use a
    574     processor out of the set of ready tasks.  One method is to assign each task
    575     a priority number and assign the tasks with the lowest priority number to
    576     one processor of the set of processors owned by a scheduler instance.
    577 
    578 :dfn:`scheduler instance`
    579     A :dfn:`scheduler instance` is a scheduling algorithm with a corresponding
    580     context to store its internal state.  Each processor in the system is owned
    581     by at most one scheduler instance.  The processor to scheduler instance
    582     assignment is determined at application configuration time.  See
    583     :ref:`Configuring a System`.
    584 
    585 :dfn:`segments`
    586     Variable sized memory blocks allocated from a region.
    587 
    588 :dfn:`semaphore`
    589     An RTEMS object which is used to synchronize tasks and provide mutually
    590     exclusive access to resources.
    591 
    592 :dfn:`Semaphore Control Block`
    593     A data structure associated with each semaphore used by RTEMS to manage
    594     that semaphore.
    595 
    596 :dfn:`shared memory`
    597     Memory which is accessible by multiple nodes in a multiprocessor system.
    598 
    599 :dfn:`signal`
    600     An RTEMS provided mechanism to communicate asynchronously with a task.
    601     Upon reception of a signal, the ASR of the receiving task will be invoked.
    602 
    603 :dfn:`signal set`
    604     A thirty-two bit entity which is used to represent a task's collection of
    605     pending signals and the signals sent to a task.
    606 
    607 :dfn:`SMCB`
    608     An acronym for Semaphore Control Block.
    609 
    610 :dfn:`SMP locks`
    611     The :dfn:`SMP locks` ensure mutual exclusion on the lowest level and are a
    612     replacement for the sections of disabled interrupts.  Interrupts are
    613     usually disabled while holding an SMP lock.  They are implemented using
    614     atomic operations.  Currently a ticket lock is used in RTEMS.
    615 
    616 :dfn:`SMP barriers`
    617     The :dfn:`SMP barriers` ensure that a defined set of independent threads of
    618     execution on a set of processors reaches a common synchronization point in
    619     time.  They are implemented using atomic operations.  Currently a sense
    620     barrier is used in RTEMS.
    621 
    622 :dfn:`soft real-time system`
    623     A real-time system in which a missed deadline does not compromise the
    624     integrity of the system.
    625 
    626 :dfn:`sporadic task`
    627     A task which executes at irregular intervals and must comply with a hard
    628     deadline.  A minimum period of time between successive iterations of the
    629     task can be guaranteed.
    630 
    631 :dfn:`stack`
    632     A data structure that is managed using a Last In First Out (LIFO)
    633     discipline.  Each task has a stack associated with it which is used to
    634     store return information and local variables.
    635 
    636 :dfn:`status code`
    637     Also known as error code or return value.
    638 
    639 :dfn:`suspend`
    640     A term used to describe a task that is not competing for the CPU because it
    641     has had a ``rtems_task_suspend`` directive.
    642 
    643 :dfn:`synchronous`
    644     Related in order or timing to other occurrences in the system.
    645 
    646 :dfn:`system call`
    647     In this document, this is used as an alternate term for directive.
    648 
    649 :dfn:`target`
    650     The system on which the application will ultimately execute.
    651 
    652 .. _task:
    653 
    654 :dfn:`task`
    655     A logically complete thread of execution.  It consists normally of a set of
    656     registers and a stack.  The scheduler assigns processors to a subset of the
    657     ready tasks.  The terms :dfn:`task` and :dfn:`thread` are synonym in RTEMS.
    658     The term :dfn:`task` is used throughout the Classic API, however,
    659     internally in the operating system implementation and the POSIX API the
    660     term :dfn:`thread` is used.
    661 
    662 :dfn:`Task Control Block`
    663     A data structure associated with each task used by RTEMS to manage that
    664     task.
    665 
    666 :dfn:`task migration`
    667     :dfn:`Task migration` happens in case a task stops execution on one
    668     processor and resumes execution on another processor.
    669 
    670 :dfn:`task processor affinity`
    671     The set of processors on which a task is allowed to execute.
    672 
    673 :dfn:`task switch`
    674     Alternate terminology for context switch.  Taking control of the processor
    675     from one task and given to another.
    676 
    677 :dfn:`TCB`
    678     An acronym for Task Control Block.
    679 
    680 :dfn:`thread`
    681     See :ref:`task <task>`.
    682 
    683 :dfn:`thread dispatch`
    684     The :dfn:`thread dispatch` transfers control of the processor from the
    685     currently executing thread to the heir thread of the processor.
    686 
    687 :dfn:`tick`
    688     The basic unit of time used by RTEMS.  It is a user-configurable number of
    689     microseconds.  The current tick expires when a clock tick directive is
    690     invoked.
    691 
    692 :dfn:`tightly-coupled`
    693     A multiprocessor configuration system which communicates via shared memory.
    694 
    695 :dfn:`timeout`
    696     An argument provided to a number of directives which determines the maximum
    697     length of time an application task is willing to wait to acquire the
    698     resource if it is not immediately available.
    699 
    700 :dfn:`timer`
    701     An RTEMS object used to invoke subprograms at a later time.
    702 
    703 :dfn:`Timer Control Block`
    704     A data structure associated with each timer used by RTEMS to manage that
    705     timer.
    706 
    707 :dfn:`timeslicing`
    708     A task scheduling discipline in which tasks of equal priority are executed
    709     for a specific period of time before being preempted by another task.
    710 
    711 :dfn:`timeslice`
    712     The application defined unit of time in which the processor is allocated.
    713 
    714 .. _TLS:
    715 
    716 :dfn:`TLS`
    717     An acronym for Thread-Local Storage :cite:`Drepper:2013:TLS`.  TLS is
    718     available in :ref:`C11 <C11>` and :ref:`C++11 <C++11>`.  The support for
    719     TLS depends on the CPU port :cite:`RTEMS:CPU`.
    720 
    721 :dfn:`TMCB`
    722     An acronym for Timer Control Block.
    723 
    724 :dfn:`transient overload`
    725     A temporary rise in system activity which may cause deadlines to be missed.
    726     Rate Monotonic Scheduling can be used to determine if all deadlines will be
    727     met under transient overload.
    728 
    729 :dfn:`user extensions`
    730     Software routines provided by the application to enhance the functionality
    731     of RTEMS.
    732 
    733 :dfn:`User Extension Table`
    734     A table which contains the entry points for each user extensions.
    735 
    736 :dfn:`User Initialization Tasks Table`
    737     A table which contains the information needed to create and start each of
    738     the user initialization tasks.
    739 
    740 :dfn:`user-provided`
    741     Alternate term for user-supplied.  This term is used to designate any
    742     software routines which must be written by the application designer.
    743 
    744 :dfn:`user-supplied`
    745     Alternate term for user-provided.  This term is used to designate any
    746     software routines which must be written by the application designer.
    747 
    748 :dfn:`vector`
    749     Memory pointers used by the processor to fetch the address of routines
    750     which will handle various exceptions and interrupts.
    751 
    752 :dfn:`wait queue`
    753     The list of tasks blocked pending the release of a particular resource.
    754     Message queues, regions, and semaphores have a wait queue associated with
    755     them.
    756 
    757 :dfn:`yield`
    758     When a task voluntarily releases control of the processor.
     6.. glossary::
     7   :sorted:
     8
     9   active
     10      A term used to describe an object which has been created by an
     11      application.
     12
     13   aperiodic task
     14      A task which must execute only at irregular intervals and has only a soft
     15      deadline.
     16
     17   application
     18      In this document, software which makes use of RTEMS.
     19
     20   ASR
     21      see Asynchronous Signal Routine.
     22
     23   asynchronous
     24      Not related in order or timing to other occurrences in the system.
     25
     26   Asynchronous Signal Routine
     27      Similar to a hardware interrupt except that it is associated with a task
     28      and is run in the context of a task.  The directives provided by the
     29      signal manager are used to service signals.
     30
     31   atomic operations
     32      Atomic operations are defined in terms of :term:`C11`.
     33
     34   awakened
     35      A term used to describe a task that has been unblocked and may be
     36      scheduled to the CPU.
     37
     38   big endian
     39      A data representation scheme in which the bytes composing a numeric value
     40      are arranged such that the most significant byte is at the lowest
     41      address.
     42
     43   bit-mapped
     44      A data encoding scheme in which each bit in a variable is used to
     45      represent something different.  This makes for compact data
     46      representation.
     47
     48   block
     49      A physically contiguous area of memory.
     50
     51   blocked task
     52      The task state entered by a task which has been previously started and
     53      cannot continue execution until the reason for waiting has been
     54      satisfied.  Blocked tasks are not an element of the set of ready tasks of
     55      a scheduler instance.
     56
     57   broadcast
     58      To simultaneously send a message to a logical set of destinations.
     59
     60   BSP
     61      see Board Support Package.
     62
     63   Board Support Package
     64      A collection of device initialization and control routines specific to a
     65      particular type of board or collection of boards.
     66
     67   buffer
     68      A fixed length block of memory allocated from a partition.
     69
     70   C11
     71      The standard ISO/IEC 9899:2011.
     72
     73   C++11
     74      The standard ISO/IEC 14882:2011.
     75
     76   calling convention
     77      The processor and compiler dependent rules which define the mechanism
     78      used to invoke subroutines in a high-level language.  These rules define
     79      the passing of arguments, the call and return mechanism, and the register
     80      set which must be preserved.
     81
     82   Central Processing Unit
     83      This term is equivalent to the terms processor and microprocessor.
     84
     85   chain
     86      A data structure which allows for efficient dynamic addition and removal
     87      of elements.  It differs from an array in that it is not limited to a
     88      predefined size.
     89
     90   cluster
     91      We have clustered scheduling in case the set of processors of a system is
     92      partitioned into non-empty pairwise disjoint subsets.  These subsets are
     93      calledclusters.  Clusters with a cardinality of one are partitions.  Each
     94      cluster is owned by exactly one scheduler instance.
     95
     96   coalesce
     97      The process of merging adjacent holes into a single larger hole.
     98      Sometimes this process is referred to as garbage collection.
     99
     100   Configuration Table
     101      A table which contains information used to tailor RTEMS for a particular
     102      application.
     103
     104   context
     105      All of the processor registers and operating system data structures
     106      associated with a task.
     107
     108   context switch
     109      Alternate term for task switch.  Taking control of the processor from one
     110      task and transferring it to another task.
     111
     112   control block
     113      A data structure used by the executive to define and control an object.
     114
     115   core
     116      When used in this manual, this term refers to the internal executive
     117      utility functions.  In the interest of application portability, the core
     118      of the executive should not be used directly by applications.
     119
     120   CPU
     121      An acronym for Central Processing Unit.
     122
     123   critical section
     124      A section of code which must be executed indivisibly.
     125
     126   CRT
     127      An acronym for Cathode Ray Tube.  Normally used in reference to the
     128      man-machine interface.
     129
     130   deadline
     131      A fixed time limit by which a task must have completed a set of actions.
     132      Beyond this point, the results are of reduced value and may even be
     133      considered useless or harmful.
     134
     135   device
     136      A peripheral used by the application that requires special operation
     137      software.  See also device driver.
     138
     139   device driver
     140      Control software for special peripheral devices used by the application.
     141
     142   directives
     143      RTEMS' provided routines that provide support mechanisms for real-time
     144      applications.
     145
     146   dispatch
     147      The act of loading a task's context onto the CPU and transferring control
     148      of the CPU to that task.
     149
     150   dormant
     151      The state entered by a task after it is created and before it has been
     152      started.
     153
     154   Device Driver Table
     155      A table which contains the entry points for each of the configured device
     156      drivers.
     157
     158   dual-ported
     159      A term used to describe memory which can be accessed at two different
     160      addresses.
     161
     162   embedded
     163      An application that is delivered as a hidden part of a larger system.
     164      For example, the software in a fuel-injection control system is an
     165      embedded application found in many late-model automobiles.
     166
     167   envelope
     168      A buffer provided by the MPCI layer to RTEMS which is used to pass
     169      messages between nodes in a multiprocessor system.  It typically contains
     170      routing information needed by the MPCI.  The contents of an envelope are
     171      referred to as a packet.
     172
     173   entry point
     174      The address at which a function or task begins to execute.  In C, the
     175      entry point of a function is the function's name.
     176
     177   events
     178      A method for task communication and synchronization. The directives
     179      provided by the event manager are used to service events.
     180
     181   exception
     182      A synonym for interrupt.
     183
     184   executing task
     185      The task state entered by a task after it has been given control of the
     186      processor.  In SMP configurations, a task may be registered as executing
     187      on more than one processor for short time frames during task migration.
     188      Blocked tasks can be executing until they issue a thread dispatch.
     189
     190   executive
     191      In this document, this term is used to referred to RTEMS.  Commonly, an
     192      executive is a small real-time operating system used in embedded systems.
     193
     194   exported
     195      An object known by all nodes in a multiprocessor system.  An object
     196      created with the GLOBAL attribute will be exported.
     197
     198   external address
     199      The address used to access dual-ported memory by all the nodes in a
     200      system which do not own the memory.
     201
     202   FIFO
     203      An acronym for First In First Out.
     204
     205   First In First Out
     206      A discipline for manipulating entries in a data structure.
     207
     208   floating point coprocessor
     209      A component used in computer systems to enhance performance in
     210      mathematically intensive situations.  It is typically viewed as a logical
     211      extension of the primary processor.
     212
     213   freed
     214      A resource that has been released by the application to RTEMS.
     215
     216   global
     217      An object that has been created with the GLOBAL attribute and exported to
     218      all nodes in a multiprocessor system.
     219
     220   handler
     221      The equivalent of a manager, except that it is internal to RTEMS and
     222      forms part of the core.  A handler is a collection of routines which
     223      provide a related set of functions.  For example, there is a handler used
     224      by RTEMS to manage all objects.
     225
     226   hard real-time system
     227      A real-time system in which a missed deadline causes the worked performed
     228      to have no value or to result in a catastrophic effect on the integrity
     229      of the system.
     230
     231   heap
     232      A data structure used to dynamically allocate and deallocate variable
     233      sized blocks of memory.
     234
     235   heir task
     236      A task is an heir if it is registered as an heir in a processor of the
     237      system.  A task can be the heir on at most one processor in the system.
     238      In case the executing and heir tasks differ on a processor and a thread
     239      dispatch is marked as necessary, then the next thread dispatch will make
     240      the heir task the executing task.
     241
     242   heterogeneous
     243      A multiprocessor computer system composed of dissimilar processors.
     244
     245   homogeneous
     246      A multiprocessor computer system composed of a single type of processor.
     247
     248   ID
     249      An RTEMS assigned identification tag used to access an active object.
     250
     251   IDLE task
     252      A special low priority task which assumes control of the CPU when no
     253      other task is able to execute.
     254
     255   interface
     256      A specification of the methodology used to connect multiple independent
     257      subsystems.
     258
     259   internal address
     260      The address used to access dual-ported memory by the node which owns the
     261      memory.
     262
     263   interrupt
     264      A hardware facility that causes the CPU to suspend execution, save its
     265      status, and transfer control to a specific location.
     266
     267   interrupt level
     268      A mask used to by the CPU to determine which pending interrupts should be
     269      serviced.  If a pending interrupt is below the current interrupt level,
     270      then the CPU does not recognize that interrupt.
     271
     272   Interrupt Service Routine
     273      An ISR is invoked by the CPU to process a pending interrupt.
     274
     275   I/O
     276      An acronym for Input/Output.
     277
     278   ISR
     279      An acronym for Interrupt Service Routine.
     280
     281   kernel
     282      In this document, this term is used as a synonym for executive.
     283
     284   list
     285      A data structure which allows for dynamic addition and removal of
     286      entries.  It is not statically limited to a particular size.
     287
     288   little endian
     289      A data representation scheme in which the bytes composing a numeric value
     290      are arranged such that the least significant byte is at the lowest
     291      address.
     292
     293   local
     294      An object which was created with the LOCAL attribute and is accessible
     295      only on the node it was created and resides upon.  In a single processor
     296      configuration, all objects are local.
     297
     298   local operation
     299      The manipulation of an object which resides on the same node as the
     300      calling task.
     301
     302   logical address
     303      An address used by an application.  In a system without memory
     304      management, logical addresses will equal physical addresses.
     305
     306   loosely-coupled
     307      A multiprocessor configuration where shared memory is not used for
     308      communication.
     309
     310   major number
     311      The index of a device driver in the Device Driver Table.
     312
     313   manager
     314      A group of related RTEMS' directives which provide access and control
     315      over resources.
     316
     317   memory pool
     318      Used interchangeably with heap.
     319
     320   message
     321      A sixteen byte entity used to communicate between tasks.  Messages are
     322      sent to message queues and stored in message buffers.
     323
     324   message buffer
     325      A block of memory used to store messages.
     326
     327   message queue
     328      An RTEMS object used to synchronize and communicate between tasks by
     329      transporting messages between sending and receiving tasks.
     330
     331   Message Queue Control Block
     332      A data structure associated with each message queue used by RTEMS to
     333      manage that message queue.
     334
     335   minor number
     336      A numeric value passed to a device driver, the exact usage of which is
     337      driver dependent.
     338
     339   mode
     340      An entry in a task's control block that is used to determine if the task
     341      allows preemption, timeslicing, processing of signals, and the interrupt
     342      disable level used by the task.
     343
     344   MPCI
     345      An acronym for Multiprocessor Communications Interface Layer.
     346
     347   multiprocessing
     348      The simultaneous execution of two or more processes by a multiple
     349      processor computer system.
     350
     351   multiprocessor
     352      A computer with multiple CPUs available for executing applications.
     353
     354   Multiprocessor Communications Interface Layer
     355      A set of user-provided routines which enable the nodes in a
     356      multiprocessor system to communicate with one another.
     357
     358   Multiprocessor Configuration Table
     359      The data structure defining the characteristics of the multiprocessor
     360      target system with which RTEMS will communicate.
     361
     362   multitasking
     363      The alternation of execution amongst a group of processes on a single
     364      CPU.  A scheduling algorithm is used to determine which process executes
     365      at which time.
     366
     367   mutual exclusion
     368      A term used to describe the act of preventing other tasks from accessing
     369      a resource simultaneously.
     370
     371   nested
     372      A term used to describe an ASR that occurs during another ASR or an ISR
     373      that occurs during another ISR.
     374
     375   node
     376      A term used to reference a processor running RTEMS in a multiprocessor
     377      system.
     378
     379   non-existent
     380      The state occupied by an uncreated or deleted task.
     381
     382   numeric coprocessor
     383      A component used in computer systems to enhance performance in
     384      mathematically intensive situations.  It is typically viewed as a logical
     385      extension of the primary processor.
     386
     387   object
     388      In this document, this term is used to refer collectively to tasks,
     389      timers, message queues, partitions, regions, semaphores, ports, and rate
     390      monotonic periods.  All RTEMS objects have IDs and user-assigned names.
     391
     392   object-oriented
     393      A term used to describe systems with common mechanisms for utilizing a
     394      variety of entities.  Object-oriented systems shield the application from
     395      implementation details.
     396
     397   operating system
     398      The software which controls all the computer's resources and provides the
     399      base upon which application programs can be written.
     400
     401   overhead
     402      The portion of the CPUs processing power consumed by the operating
     403      system.
     404
     405   packet
     406      A buffer which contains the messages passed between nodes in a
     407      multiprocessor system.  A packet is the contents of an envelope.
     408
     409   partition
     410      An RTEMS object which is used to allocate and deallocate fixed size
     411      blocks of memory from an dynamically specified area of memory.
     412
     413   partition
     414      Clusters with a cardinality of one are partitions.
     415
     416   Partition Control Block
     417      A data structure associated with each partition used by RTEMS to manage
     418      that partition.
     419
     420   pending
     421      A term used to describe a task blocked waiting for an event, message,
     422      semaphore, or signal.
     423
     424   periodic task
     425      A task which must execute at regular intervals and comply with a hard
     426      deadline.
     427
     428   physical address
     429      The actual hardware address of a resource.
     430
     431   poll
     432      A mechanism used to determine if an event has occurred by periodically
     433      checking for a particular status.  Typical events include arrival of
     434      data, completion of an action, and errors.
     435
     436   pool
     437      A collection from which resources are allocated.
     438
     439   portability
     440      A term used to describe the ease with which software can be rehosted on
     441      another computer.
     442
     443   posting
     444      The act of sending an event, message, semaphore, or signal to a task.
     445
     446   preempt
     447      The act of forcing a task to relinquish the processor and dispatching to
     448      another task.
     449
     450   priority
     451      A mechanism used to represent the relative importance of an element in a
     452      set of items.  RTEMS uses priority to determine which task should
     453      execute.
     454
     455   priority boosting
     456      A simple approach to extend the priority inheritance protocol for
     457      clustered scheduling is priority boosting.  In case a mutex is owned by a
     458      task of another cluster, then the priority of the owner task is raised to
     459      an artificially high priority, the pseudo-interrupt priority.
     460
     461   priority inheritance
     462      An algorithm that calls for the lower priority task holding a resource to
     463      have its priority increased to that of the highest priority task blocked
     464      waiting for that resource.  This avoids the problem of priority
     465      inversion.
     466
     467   priority inversion
     468      A form of indefinite postponement which occurs when a high priority tasks
     469      requests access to shared resource currently allocated to low priority
     470      task.  The high priority task must block until the low priority task
     471      releases the resource.
     472
     473   processor utilization
     474      The percentage of processor time used by a task or a set of tasks.
     475
     476   proxy
     477      An RTEMS control structure used to represent, on a remote node, a task
     478      which must block as part of a remote operation.
     479
     480   Proxy Control Block
     481      A data structure associated with each proxy used by RTEMS to manage that
     482      proxy.
     483
     484   PTCB
     485      An acronym for Partition Control Block.
     486
     487   PXCB
     488      An acronym for Proxy Control Block.
     489
     490   quantum
     491      The application defined unit of time in which the processor is allocated.
     492
     493   queue
     494      Alternate term for message queue.
     495
     496   QCB
     497      An acronym for Message Queue Control Block.
     498
     499   ready task
     500      A task occupies this state when it is available to be given control of a
     501      processor.  A ready task has no processor assigned.  The scheduler
     502      decided that other tasks are currently more important.  A task that is
     503      ready to execute and has a processor assigned is called scheduled.
     504
     505   real-time
     506      A term used to describe systems which are characterized by requiring
     507      deterministic response times to external stimuli.  The external stimuli
     508      require that the response occur at a precise time or the response is
     509      incorrect.
     510
     511   reentrant
     512      A term used to describe routines which do not modify themselves or global
     513      variables.
     514
     515   region
     516      An RTEMS object which is used to allocate and deallocate variable size
     517      blocks of memory from a dynamically specified area of memory.
     518
     519   Region Control Block
     520      A data structure associated with each region used by RTEMS to manage that
     521      region.
     522
     523   registers
     524      Registers are locations physically located within a component, typically
     525      used for device control or general purpose storage.
     526
     527   remote
     528      Any object that does not reside on the local node.
     529
     530   remote operation
     531      The manipulation of an object which does not reside on the same node as
     532      the calling task.
     533
     534   return code
     535      Also known as error code or return value.
     536
     537   resource
     538      A hardware or software entity to which access must be controlled.
     539
     540   resume
     541      Removing a task from the suspend state.  If the task's state is ready
     542      following a call to the ``rtems_task_resume`` directive, then the task is
     543      available for scheduling.
     544
     545   return code
     546      A value returned by RTEMS directives to indicate the completion status of
     547      the directive.
     548
     549   RNCB
     550      An acronym for Region Control Block.
     551
     552   round-robin
     553      A task scheduling discipline in which tasks of equal priority are
     554      executed in the order in which they are made ready.
     555
     556   RS-232
     557      A standard for serial communications.
     558
     559   running
     560      The state of a rate monotonic timer while it is being used to delineate a
     561      period.  The timer exits this state by either expiring or being canceled.
     562
     563   schedulable
     564      A set of tasks which can be guaranteed to meet their deadlines based upon
     565      a specific scheduling algorithm.
     566
     567   schedule
     568      The process of choosing which task should next enter the executing state.
     569
     570   scheduled task
     571      A task is scheduled if it is allowed to execute and has a processor
     572      assigned.  Such a task executes currently on a processor or is about to
     573      start execution.  A task about to start execution it is an heir task on
     574      exactly one processor in the system.
     575
     576   scheduler
     577      A scheduler or scheduling algorithm allocates processors to a subset of
     578      its set of ready tasks.  So it manages access to the processor resource.
     579      Various algorithms exist to choose the tasks allowed to use a processor
     580      out of the set of ready tasks.  One method is to assign each task a
     581      priority number and assign the tasks with the lowest priority number to
     582      one processor of the set of processors owned by a scheduler instance.
     583
     584   scheduler instance
     585      A scheduler instance is a scheduling algorithm with a corresponding
     586      context to store its internal state.  Each processor in the system is
     587      owned by at most one scheduler instance.  The processor to scheduler
     588      instance assignment is determined at application configuration time.  See
     589      :ref:`Configuring a System`.
     590
     591   segments
     592      Variable sized memory blocks allocated from a region.
     593
     594   semaphore
     595      An RTEMS object which is used to synchronize tasks and provide mutually
     596      exclusive access to resources.
     597
     598   Semaphore Control Block
     599      A data structure associated with each semaphore used by RTEMS to manage
     600      that semaphore.
     601
     602   shared memory
     603      Memory which is accessible by multiple nodes in a multiprocessor system.
     604
     605   signal
     606      An RTEMS provided mechanism to communicate asynchronously with a task.
     607      Upon reception of a signal, the ASR of the receiving task will be
     608      invoked.
     609
     610   signal set
     611      A thirty-two bit entity which is used to represent a task's collection of
     612      pending signals and the signals sent to a task.
     613
     614   SMCB
     615      An acronym for Semaphore Control Block.
     616
     617   SMP locks
     618      The SMP locks ensure mutual exclusion on the lowest level and are a
     619      replacement for the sections of disabled interrupts.  Interrupts are
     620      usually disabled while holding an SMP lock.  They are implemented using
     621      atomic operations.  Currently a ticket lock is used in RTEMS.
     622
     623   SMP barriers
     624      The SMP barriers ensure that a defined set of independent threads of
     625      execution on a set of processors reaches a common synchronization point
     626      in time.  They are implemented using atomic operations.  Currently a
     627      sense barrier is used in RTEMS.
     628
     629   soft real-time system
     630      A real-time system in which a missed deadline does not compromise the
     631      integrity of the system.
     632
     633   sporadic task
     634      A task which executes at irregular intervals and must comply with a hard
     635      deadline.  A minimum period of time between successive iterations of the
     636      task can be guaranteed.
     637
     638   stack
     639      A data structure that is managed using a Last In First Out (LIFO)
     640      discipline.  Each task has a stack associated with it which is used to
     641      store return information and local variables.
     642
     643   status code
     644      Also known as error code or return value.
     645
     646   suspend
     647      A term used to describe a task that is not competing for the CPU because it
     648      has had a ``rtems_task_suspend`` directive.
     649
     650   synchronous
     651      Related in order or timing to other occurrences in the system.
     652
     653   system call
     654      In this document, this is used as an alternate term for directive.
     655
     656   target
     657      The system on which the application will ultimately execute.
     658
     659   task
     660   thread
     661      A logically complete thread of execution.  It consists normally of a set
     662      of registers and a stack.  The scheduler assigns processors to a subset
     663      of the ready tasks.  The terms task and thread are synonym in RTEMS.  The
     664      term task is used throughout the Classic API, however, internally in the
     665      operating system implementation and the POSIX API the term thread is
     666      used.
     667
     668   Task Control Block
     669      A data structure associated with each task used by RTEMS to manage that
     670      task.
     671
     672   task migration
     673      Task migration happens in case a task stops execution on one processor
     674      and resumes execution on another processor.
     675
     676   task processor affinity
     677      The set of processors on which a task is allowed to execute.
     678
     679   task switch
     680      Alternate terminology for context switch.  Taking control of the
     681      processor from one task and given to another.
     682
     683   TCB
     684      An acronym for Task Control Block.
     685
     686   thread dispatch
     687      The thread dispatch transfers control of the processor from the currently
     688      executing thread to the heir thread of the processor.
     689
     690   tick
     691      The basic unit of time used by RTEMS.  It is a user-configurable number
     692      of microseconds.  The current tick expires when a clock tick directive is
     693      invoked.
     694
     695   tightly-coupled
     696      A multiprocessor configuration system which communicates via shared
     697      memory.
     698
     699   timeout
     700      An argument provided to a number of directives which determines the
     701      maximum length of time an application task is willing to wait to acquire
     702      the resource if it is not immediately available.
     703
     704   timer
     705      An RTEMS object used to invoke subprograms at a later time.
     706
     707   Timer Control Block
     708      A data structure associated with each timer used by RTEMS to manage that
     709      timer.
     710
     711   timeslicing
     712      A task scheduling discipline in which tasks of equal priority are
     713      executed for a specific period of time before being preempted by another
     714      task.
     715
     716   timeslice
     717      The application defined unit of time in which the processor is allocated.
     718
     719   TLS
     720      An acronym for Thread-Local Storage :cite:`Drepper:2013:TLS`.  TLS is
     721      available in :term:`C11` and :term:`C++11`.  The support for TLS depends
     722      on the CPU port :cite:`RTEMS:CPU`.
     723
     724   TMCB
     725      An acronym for Timer Control Block.
     726
     727   transient overload
     728      A temporary rise in system activity which may cause deadlines to be
     729      missed.  Rate Monotonic Scheduling can be used to determine if all
     730      deadlines will be met under transient overload.
     731
     732   user extensions
     733      Software routines provided by the application to enhance the
     734      functionality of RTEMS.
     735
     736   User Extension Table
     737      A table which contains the entry points for each user extensions.
     738
     739   User Initialization Tasks Table
     740      A table which contains the information needed to create and start each of
     741      the user initialization tasks.
     742
     743   user-provided
     744   user-supplied
     745      These terms are used to designate any software routines which must be
     746      written by the application designer.
     747
     748   vector
     749      Memory pointers used by the processor to fetch the address of routines
     750      which will handle various exceptions and interrupts.
     751
     752   wait queue
     753      The list of tasks blocked pending the release of a particular resource.
     754      Message queues, regions, and semaphores have a wait queue associated with
     755      them.
     756
     757   yield
     758      When a task voluntarily releases control of the processor.
  • c-user/key_concepts.rst

    r2e0a2a0 r3e005fe  
    360360.. index:: thread queues
    361361
    362 In case more than one :ref:`thread <task>` may wait on a synchronization
    363 object, e.g. a semaphore or a message queue, then the waiting threads are added
    364 to a data structure called the thread queue.  Thread queues are named task wait
    365 queues in the Classic API.  There are two thread queuing disciplines available
    366 which define the order of the threads on a particular thread queue.  Threads
    367 can wait in FIFO or priority order.
     362In case more than one :term:`thread` may wait on a synchronization object, e.g.
     363a semaphore or a message queue, then the waiting threads are added to a data
     364structure called the thread queue.  Thread queues are named task wait queues in
     365the Classic API.  There are two thread queuing disciplines available which
     366define the order of the threads on a particular thread queue.  Threads can wait
     367in FIFO or priority order.
    368368
    369369In uni-processor configurations, the priority queuing discipline just orders
Note: See TracChangeset for help on using the changeset viewer.