|
|
.. SPDX-License-Identifier: CC-BY-SA-4.0
.. Copyright (C) 2022, 2023 Trinity College Dublin
.. Copyright (C) 2017, 2019 embedded brains GmbH & Co. KG
.. Copyright (C) 1988, 1998 On-Line Applications Research Corporation (OAR)
Glossary
********
.. glossary::
:sorted:
API
This term is an acronym for Application Programming Interface.
assembler language
The assembler language is a programming language which can be translated very
easily into machine code and data. For this project assembler languages are
restricted to languages accepted by the :term:`GNU` assembler
program for the target architectures.
C language
The C language for this project is defined in terms of
:term:`C11`.
C11
The standard ISO/IEC 9899:2011.
CCB
This term is an acronym for Change Control Board.
Doorstop
`Doorstop <https://github.com/doorstop-dev/doorstop>`_ is a
requirements management tool.
EARS
This term is an acronym for Easy Approach to Requirements Syntax.
ELF
This term is an acronym for
`Executable and Linkable Format <https://en.wikipedia.org/wiki/Executable_and_Linkable_Format>`_.
formal model
A model of a computing component (hardware or software) that has a
mathematically based :term:`semantics`.
GCC
This term is an acronym for `GNU Compiler Collection <https://gcc.gnu.org/>`_.
GNAT
*GNAT* is the :term:`GNU` compiler for Ada, integrated into the
:term:`GCC`.
GNU
This term is an acronym for `GNU's Not Unix <https://www.gnu.org/>`_.
interrupt service
An *interrupt service* consists of an
:term:`Interrupt Service Routine` which is called with a user
provided argument upon reception of an interrupt service request. The
routine is invoked in interrupt context. Interrupt service requests may have
a priority and an affinity to a set of processors. An *interrupt service* is
a :term:`software component`.
Interrupt Service Routine
An ISR is invoked by the CPU to process a pending interrupt.
ISVV
This term is an acronym for Independent Software Verification and Validation.
Linear Temporal Logic
This is a logic that states properties about (possibly infinite) sequences of
states.
LTL
This term is an acronym for :term:`Linear Temporal Logic`.
refinement
A *refinement* is a relationship between a specification and its
implementation as code.
reification
Another term used to denote :term:`refinement`.
ReqIF
This term is an acronym for
`Requirements Interchange Format <https://www.omg.org/spec/ReqIF/About-ReqIF/>`_.
RTEMS
This term is an acronym for Real-Time Executive for Multiprocessor Systems.
scenario
In the context of formal verification, in a setting that involves many
concurrent tasks that interleave in arbitrary ways, a scenario describes a
single specific possible interleaving. One interpretation of the behaviour
of a concurrent system is the set of all its scenarios.
semantics
This term refers to the meaning of text or utterances in some language. In a
software engineering context these will be programming, modelling or
specification languages.
software component
This term is defined by ECSS-E-ST-40C 3.2.28 as a "part of a software
system". For this project a *software component* shall be any of the
following items and nothing else:
* :term:`software unit`
* explicitly defined :term:`ELF` symbol in a
:term:`source code` file
* :term:`assembler language` data in a source code file
* :term:`C language` object with static storage duration
* C language object with thread-local storage duration
* :term:`thread`
* :term:`interrupt service`
* collection of *software components* (this is a software architecture
element)
Please note that explicitly defined ELF symbols and assembler language
data are considered a software component only if they are defined in a
:term:`source code` file. For example, this rules out symbols
and data generated as side-effects by the toolchain (compiler, assembler,
linker) such as jump tables, linker trampolines, exception frame information,
etc.
software product
The *software product* is the :term:`RTEMS` real-time operating system.
software unit
This term is defined by ECSS-E-ST-40C 3.2.24 as a "separately compilable
piece of source code". For this project a *software unit* shall be any of
the following items and nothing else:
* :term:`assembler language` function in a
:term:`source code` file
* :term:`C language` function (external and internal linkage)
A *software unit* is a :term:`software component`.
source code
This project uses the *source code* definition of the
`Linux Information Project <http://www.linfo.org/source_code.html>`_:
"Source code (also referred to as source or code) is the version of
software as it is originally written (i.e., typed into a computer) by a
human in plain text (i.e., human readable alphanumeric characters)."
target
The system on which the application will ultimately execute.
task
This project uses the
`thread definition of Wikipedia <https://en.wikipedia.org/wiki/Thread_(computing)>`_:
"a thread of execution is the smallest sequence of programmed
instructions that can be managed independently by a scheduler, which is
typically a part of the operating system."
It consists normally of a set of registers and a stack. The scheduler
assigns processors to a subset of the ready tasks. The terms task and
:term:`thread` are synonym in RTEMS. The term task is used
throughout the Classic API, however, internally in the operating system
implementation and the POSIX API the term thread is used.
A *task* is a :term:`software component`.
thread
This term has the same meaning as :term:`task`.
YAML
This term is an acronym for `YAML Ain't Markup Language <https://yaml.org/>`_.
|
