From 72a62ad88f82fe1ffee50024db4dd0f3fa5806f7 Mon Sep 17 00:00:00 2001 From: Chris Johns Date: Thu, 3 Nov 2016 16:58:08 +1100 Subject: Rename all manuals with an _ to have a -. It helps released naming of files. --- c-user/glossary.rst | 738 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 738 insertions(+) create mode 100644 c-user/glossary.rst (limited to 'c-user/glossary.rst') diff --git a/c-user/glossary.rst b/c-user/glossary.rst new file mode 100644 index 0000000..e7fd794 --- /dev/null +++ b/c-user/glossary.rst @@ -0,0 +1,738 @@ +.. comment SPDX-License-Identifier: CC-BY-SA-4.0 + +Glossary +######## + +:dfn:`active` + A term used to describe an object which has been created by an application. + +:dfn:`aperiodic task` + A task which must execute only at irregular intervals and has only a soft + deadline. + +:dfn:`application` + In this document, software which makes use of RTEMS. + +:dfn:`ASR` + see Asynchronous Signal Routine. + +:dfn:`asynchronous` + Not related in order or timing to other occurrences in the system. + +:dfn:`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. + +:dfn:`atomic operations` + Atomic operations are defined in terms of *ISO/IEC 9899:2011*. + +:dfn:`awakened` + A term used to describe a task that has been unblocked and may be scheduled + to the CPU. + +:dfn:`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. + +:dfn:`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. + +:dfn:`block` + A physically contiguous area of memory. + +:dfn:`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. + +:dfn:`broadcast` + To simultaneously send a message to a logical set of destinations. + +:dfn:`BSP` + see Board Support Package. + +:dfn:`Board Support Package` + A collection of device initialization and control routines specific to a + particular type of board or collection of boards. + +:dfn:`buffer` + A fixed length block of memory allocated from a partition. + +:dfn:`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. + +:dfn:`Central Processing Unit` + This term is equivalent to the terms processor and microprocessor. + +:dfn:`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. + +:dfn:`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. + +:dfn:`coalesce` + The process of merging adjacent holes into a single larger hole. Sometimes + this process is referred to as garbage collection. + +:dfn:`Configuration Table` + A table which contains information used to tailor RTEMS for a particular + application. + +:dfn:`context` + All of the processor registers and operating system data structures + associated with a task. + +:dfn:`context switch` + Alternate term for task switch. Taking control of the processor from one + task and transferring it to another task. + +:dfn:`control block` + A data structure used by the executive to define and control an object. + +:dfn:`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. + +:dfn:`CPU` + An acronym for Central Processing Unit. + +:dfn:`critical section` + A section of code which must be executed indivisibly. + +:dfn:`CRT` + An acronym for Cathode Ray Tube. Normally used in reference to the + man-machine interface. + +:dfn:`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. + +:dfn:`device` + A peripheral used by the application that requires special operation + software. See also device driver. + +:dfn:`device driver` + Control software for special peripheral devices used by the application. + +:dfn:`directives` + RTEMS' provided routines that provide support mechanisms for real-time + applications. + +:dfn:`dispatch` + The act of loading a task's context onto the CPU and transferring control + of the CPU to that task. + +:dfn:`dormant` + The state entered by a task after it is created and before it has been + started. + +:dfn:`Device Driver Table` + A table which contains the entry points for each of the configured device + drivers. + +:dfn:`dual-ported` + A term used to describe memory which can be accessed at two different + addresses. + +:dfn:`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. + +:dfn:`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. + +:dfn:`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. + +:dfn:`events` + A method for task communication and synchronization. The directives + provided by the event manager are used to service events. + +:dfn:`exception` + A synonym for interrupt. + +:dfn:`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. + +:dfn:`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. + +:dfn:`exported` + An object known by all nodes in a multiprocessor system. An object created + with the GLOBAL attribute will be exported. + +:dfn:`external address` + The address used to access dual-ported memory by all the nodes in a system + which do not own the memory. + +:dfn:`FIFO` + An acronym for First In First Out. + +:dfn:`First In First Out` + A discipline for manipulating entries in a data structure. + +:dfn:`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. + +:dfn:`freed` + A resource that has been released by the application to RTEMS. + +:dfn:`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. + +:dfn:`global` + An object that has been created with the GLOBAL attribute and exported to + all nodes in a multiprocessor system. + +:dfn:`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. + +:dfn:`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. + +:dfn:`heap` + A data structure used to dynamically allocate and deallocate variable sized + blocks of memory. + +:dfn:`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. + +:dfn:`heterogeneous` + A multiprocessor computer system composed of dissimilar processors. + +:dfn:`homogeneous` + A multiprocessor computer system composed of a single type of processor. + +:dfn:`ID` + An RTEMS assigned identification tag used to access an active object. + +:dfn:`IDLE task` + A special low priority task which assumes control of the CPU when no other + task is able to execute. + +:dfn:`interface` + A specification of the methodology used to connect multiple independent + subsystems. + +:dfn:`internal address` + The address used to access dual-ported memory by the node which owns the + memory. + +:dfn:`interrupt` + A hardware facility that causes the CPU to suspend execution, save its + status, and transfer control to a specific location. + +:dfn:`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. + +:dfn:`Interrupt Service Routine` + An ISR is invoked by the CPU to process a pending interrupt. + +:dfn:`I/O` + An acronym for Input/Output. + +:dfn:`ISR` + An acronym for Interrupt Service Routine. + +:dfn:`kernel` + In this document, this term is used as a synonym for executive. + +:dfn:`list` + A data structure which allows for dynamic addition and removal of entries. + It is not statically limited to a particular size. + +:dfn:`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. + +:dfn:`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. + +:dfn:`local operation` + The manipulation of an object which resides on the same node as the calling + task. + +:dfn:`logical address` + An address used by an application. In a system without memory management, + logical addresses will equal physical addresses. + +:dfn:`loosely-coupled` + A multiprocessor configuration where shared memory is not used for + communication. + +:dfn:`major number` + The index of a device driver in the Device Driver Table. + +:dfn:`manager` + A group of related RTEMS' directives which provide access and control over + resources. + +:dfn:`memory pool` + Used interchangeably with heap. + +:dfn:`message` + A sixteen byte entity used to communicate between tasks. Messages are sent + to message queues and stored in message buffers. + +:dfn:`message buffer` + A block of memory used to store messages. + +:dfn:`message queue` + An RTEMS object used to synchronize and communicate between tasks by + transporting messages between sending and receiving tasks. + +:dfn:`Message Queue Control Block` + A data structure associated with each message queue used by RTEMS to manage + that message queue. + +:dfn:`minor number` + A numeric value passed to a device driver, the exact usage of which is + driver dependent. + +:dfn:`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. + +:dfn:`MPCI` + An acronym for Multiprocessor Communications Interface Layer. + +:dfn:`multiprocessing` + The simultaneous execution of two or more processes by a multiple processor + computer system. + +:dfn:`multiprocessor` + A computer with multiple CPUs available for executing applications. + +:dfn:`Multiprocessor Communications Interface Layer` + A set of user-provided routines which enable the nodes in a multiprocessor + system to communicate with one another. + +:dfn:`Multiprocessor Configuration Table` + The data structure defining the characteristics of the multiprocessor + target system with which RTEMS will communicate. + +:dfn:`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. + +:dfn:`mutual exclusion` + A term used to describe the act of preventing other tasks from accessing a + resource simultaneously. + +:dfn:`nested` + A term used to describe an ASR that occurs during another ASR or an ISR + that occurs during another ISR. + +:dfn:`node` + A term used to reference a processor running RTEMS in a multiprocessor + system. + +:dfn:`non-existent` + The state occupied by an uncreated or deleted task. + +:dfn:`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. + +:dfn:`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. + +:dfn:`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. + +:dfn:`operating system` + The software which controls all the computer's resources and provides the + base upon which application programs can be written. + +:dfn:`overhead` + The portion of the CPUs processing power consumed by the operating system. + +:dfn:`packet` + A buffer which contains the messages passed between nodes in a + multiprocessor system. A packet is the contents of an envelope. + +:dfn:`partition` + An RTEMS object which is used to allocate and deallocate fixed size blocks + of memory from an dynamically specified area of memory. + +:dfn:`partition` + Clusters with a cardinality of one are :dfn:`partitions`. + +:dfn:`Partition Control Block` + A data structure associated with each partition used by RTEMS to manage + that partition. + +:dfn:`pending` + A term used to describe a task blocked waiting for an event, message, + semaphore, or signal. + +:dfn:`periodic task` + A task which must execute at regular intervals and comply with a hard + deadline. + +:dfn:`physical address` + The actual hardware address of a resource. + +:dfn:`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. + +:dfn:`pool` + A collection from which resources are allocated. + +:dfn:`portability` + A term used to describe the ease with which software can be rehosted on + another computer. + +:dfn:`posting` + The act of sending an event, message, semaphore, or signal to a task. + +:dfn:`preempt` + The act of forcing a task to relinquish the processor and dispatching to + another task. + +:dfn:`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. + +:dfn:`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. + +:dfn:`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. + +:dfn:`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. + +:dfn:`processor utilization` + The percentage of processor time used by a task or a set of tasks. + +:dfn:`proxy` + An RTEMS control structure used to represent, on a remote node, a task + which must block as part of a remote operation. + +:dfn:`Proxy Control Block` + A data structure associated with each proxy used by RTEMS to manage that + proxy. + +:dfn:`PTCB` + An acronym for Partition Control Block. + +:dfn:`PXCB` + An acronym for Proxy Control Block. + +:dfn:`quantum` + The application defined unit of time in which the processor is allocated. + +:dfn:`queue` + Alternate term for message queue. + +:dfn:`QCB` + An acronym for Message Queue Control Block. + +:dfn:`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. + +:dfn:`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. + +:dfn:`reentrant` + A term used to describe routines which do not modify themselves or global + variables. + +:dfn:`region` + An RTEMS object which is used to allocate and deallocate variable size + blocks of memory from a dynamically specified area of memory. + +:dfn:`Region Control Block` + A data structure associated with each region used by RTEMS to manage that + region. + +:dfn:`registers` + Registers are locations physically located within a component, typically + used for device control or general purpose storage. + +:dfn:`remote` + Any object that does not reside on the local node. + +:dfn:`remote operation` + The manipulation of an object which does not reside on the same node as the + calling task. + +:dfn:`return code` + Also known as error code or return value. + +:dfn:`resource` + A hardware or software entity to which access must be controlled. + +:dfn:`resume` + Removing a task from the suspend state. If the task's state is ready + following a call to the ``rtems_task_resume`` directive, then the task is + available for scheduling. + +:dfn:`return code` + A value returned by RTEMS directives to indicate the completion status of + the directive. + +:dfn:`RNCB` + An acronym for Region Control Block. + +:dfn:`round-robin` + A task scheduling discipline in which tasks of equal priority are executed + in the order in which they are made ready. + +:dfn:`RS-232` + A standard for serial communications. + +:dfn:`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. + +:dfn:`schedulable` + A set of tasks which can be guaranteed to meet their deadlines based upon a + specific scheduling algorithm. + +:dfn:`schedule` + The process of choosing which task should next enter the executing state. + +:dfn:`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. + +:dfn:`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. + +:dfn:`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. See + :ref:`Configuring a System`. + +:dfn:`segments` + Variable sized memory blocks allocated from a region. + +:dfn:`semaphore` + An RTEMS object which is used to synchronize tasks and provide mutually + exclusive access to resources. + +:dfn:`Semaphore Control Block` + A data structure associated with each semaphore used by RTEMS to manage + that semaphore. + +:dfn:`shared memory` + Memory which is accessible by multiple nodes in a multiprocessor system. + +:dfn:`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. + +:dfn:`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. + +:dfn:`SMCB` + An acronym for Semaphore Control Block. + +:dfn:`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. + +:dfn:`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. + +:dfn:`soft real-time system` + A real-time system in which a missed deadline does not compromise the + integrity of the system. + +:dfn:`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. + +:dfn:`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. + +:dfn:`status code` + Also known as error code or return value. + +:dfn:`suspend` + A term used to describe a task that is not competing for the CPU because it + has had a ``rtems_task_suspend`` directive. + +:dfn:`synchronous` + Related in order or timing to other occurrences in the system. + +:dfn:`system call` + In this document, this is used as an alternate term for directive. + +:dfn:`target` + The system on which the application will ultimately execute. + +:dfn:`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. + +:dfn:`Task Control Block` + A data structure associated with each task used by RTEMS to manage that + task. + +:dfn:`task migration` + :dfn:`Task migration` happens in case a task stops execution on one + processor and resumes execution on another processor. + +:dfn:`task processor affinity` + The set of processors on which a task is allowed to execute. + +:dfn:`task switch` + Alternate terminology for context switch. Taking control of the processor + from one task and given to another. + +:dfn:`TCB` + An acronym for Task Control Block. + +:dfn:`thread dispatch` + The :dfn:`thread dispatch` transfers control of the processor from the + currently executing thread to the heir thread of the processor. + +:dfn:`tick` + The basic unit of time used by RTEMS. It is a user-configurable number of + microseconds. The current tick expires when the ``rtems_clock_tick`` + directive is invoked. + +:dfn:`tightly-coupled` + A multiprocessor configuration system which communicates via shared memory. + +:dfn:`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. + +:dfn:`timer` + An RTEMS object used to invoke subprograms at a later time. + +:dfn:`Timer Control Block` + A data structure associated with each timer used by RTEMS to manage that + timer. + +:dfn:`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. + +:dfn:`timeslice` + The application defined unit of time in which the processor is allocated. + +:dfn:`TMCB` + An acronym for Timer Control Block. + +:dfn:`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. + +:dfn:`user extensions` + Software routines provided by the application to enhance the functionality + of RTEMS. + +:dfn:`User Extension Table` + A table which contains the entry points for each user extensions. + +:dfn:`User Initialization Tasks Table` + A table which contains the information needed to create and start each of + the user initialization tasks. + +:dfn:`user-provided` + Alternate term for user-supplied. This term is used to designate any + software routines which must be written by the application designer. + +:dfn:`user-supplied` + Alternate term for user-provided. This term is used to designate any + software routines which must be written by the application designer. + +:dfn:`vector` + Memory pointers used by the processor to fetch the address of routines + which will handle various exceptions and interrupts. + +:dfn:`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. + +:dfn:`yield` + When a task voluntarily releases control of the processor. -- cgit v1.2.3