Glossary

Introduction      FAQ   Glossary   TD 1   TD 2   TD 3   TD 4   TD 5   TD 6   TD 7

Back to the lecture.

This glossary is anything but exhaustive. The goal is to gather the main difficult or confusing keywords and their definitions in a central location. It is sorted alphabetically, and French translations are proposed when applicable.

ABI

Application Binary Interface. Specification of the function call, typing, stack organization, memory management, error and exception management conventions of an operating system (or a subclass of programs).

API

Application Programmer Interface. Specification of the classes, interfaces, types, function/methods, state variables of a library or development kit composed of multiple libraries.

Assembler (Assembleur)

The translator of assembly code to machine code.

Assembly code/language (Code/langage assembleur)

Human-readable syntax for machine code. Made of primitive instructions such as transferring data from memory to registers, registers to memory, registers to registers, performing arithmetic and logic operations on registers, and implementing simple control flow (conditional branch instructions, function calls).

Atomicity (Atomicité)

The property of a sequence of instructions appearing as a single instant with respect to instructions executing in concurrent threads. A concurrent thread accessing shared variables can observe the state of these variables before or after the execution of an atomic sequence of instructions, not their transient state within the sequence itself. Atomicity can be restricted to a sub-group of threads or relative to a specific object, restricting atomicity to shared access to this object only, see also critical section.

Bus

A computing subsystem that transfers data between computer components. It is typically composed of one or more electrical wires and dedicated controllers (microprocessors or specialized circuits) to implement a communication, synchronization and arbitration protocol among devices or processors.

Callback function

A function implementing custom reactions to a class of events: it is called a handler for this class of events. A callback function is typically called back from an underlying toolkit (e.g., a graphical user interface) or from the operating system kernel, to inform application programs and trigger reactions to specific events on the computing platform.

Compiler (Compilateur)

The translator of programs written in a high-level language (human-friendly, more portable than assembly language) to a lower level language, typically assembly code. Static compilers operate offline, at program implementation time. Just-In-Time (JIT) compilers operate within virtual execution environments, compiling the program one function/component at a time and on demand. The complete compilation process involves a compiler, an assembler and a linker.

Concurrency (Concurrence)

Concurrency is a property of systems in which the execution of several computations can occur in arbitrary relative orderings, or even simultaneously. Concurrent computations may potentially interact with each other, yielding non-deterministic results when the relative ordering of these computations is not constrained. See also concurrent threads of execution.

Critical section (Section critique)

A critical section is a sequence of instructions that accesses a shared resource (data structure or device) that must not be concurrently accessed by more than one thread of execution. Critical sections execute atomically with respect to other critical sections; atomicity can be restricted to critical sections accessing the same resource. A critical section should terminate in fixed time, and a thread, task or process should only have to wait a fixed time to enter it. Some synchronization (lock/unlock) mechanism is required at the entry and exit of the critical section to ensure exclusive use.

Descriptor (Descripteur)

File descriptor. Non-negative integer designating an opened file in a process. 0 denotes the standard input, 1 the standard output, and 2 the standard error.

Device (Périphérique)

Unix defines two kinds of devices: character devices for streaming I/O (networking, audio, frame buffer), and block devices for fixed-size block I/O and storage operations (hard disk, mass storage).

Device driver (Pilote de périphérique)

Or driver for short. Set of functions and data structures in the kernel (typically in the form of a kernel module) to translate generic I/O operations issued by the application and kernel components into low-level, device-specific operations. This include the memory transfers to the device, specific interrupt management, configuration and deconfiguration of the device, configuration of memory-mapped I/O, device-specific power management, etc.

Device special file (Fichier spécial de périphérique)

Special file for direct interation and I/O on a device. The major and minor numbers are stored in the special file's Inode and used to link the file with the kernel driver in charge of low-level device operations.

FLOPS

Floating Point Operation Per Second. Typically prefixed with Mega, Giga, Tera, Peta, and soon Exa... Performance metric for numerical computations. An addition or a multiplication count for one floating point operation. More complex operations are weighted to account for their higher resource consumption. Workstations and supercomputers generally assume double-precision operations, while Graphical Processing Units (GPUs) typically consider single-precision operations.

Handler

An event handler is an asynchronous callback function that handles events (such as inputs) received in a program. Each event is a piece of application-level information from the underlying framework, typically a graphical user interface (mouse movement, key press...) or a low-level signalling mechanism from the operating system kernel (signal, interrupt, exception).

Free software (Logiciel libre)

Free as free speech, not free beer. Free software benefits from 4 essential freedoms: (0) the freedom to run the program, for any purpose; (1) the freedom to study how the program works, and change it to make it do what you wish (access to the source code is a precondition for this); (2) the freedom to redistribute copies so you can help your neighbor; (3) the freedom to improve the program, and release your improvements (and modified versions in general) to the public, so that the whole community benefits (access to the source code is a precondition for this). These freedoms are guaranteed by license agreements, building on top of copyright law. There are many free software licenses (also called open source) with subtle but important differences.

High-level (Haut niveau)

Refers to abstraction level, programming style, type of operation, data representation or abstraction that tend to abstract away from the hardware and implementation details, aiming for portability, generality, productivity, correctness and simplicity.

Host (Hôte)

Node on the Internet Protocol (IP) network, denoted by its 32 bit IPv4 or 128 bit IPv6 address. Each machine connected to Internet may have one or more IP addresses, each one defining a IP host on the machine.

Inode

Index node. Meta-data about a file: file type (regular data, directory, device special file, soft link, FIFO pipe, socket).

Library (Bibliothèque)

Also called package or module depending on the programming language. Collection of object files, themselves built of multiple functions, types and state variables. Building block for development kits, to share common functionalities and components within an operating system and across all applications.

Link (Lien

Hard link: another Inode for a file, i.e., multiple metadata to refer to the same data blocks (restricted to regular files). Soft link: special file containing the name of another file, interpreted as an alias for this file by the kernel.

Linker (Éditeur de liens)

The tool in charge linking separately compiled program modules. It associates symbol names — functions, variables, types, etc. — in files resulting from compilation and assembly. These are called object files, and contain a mix of machine code and symbol names of exported or external functions and variables. The linker substitutes the (relative or absolute) memory adresses of these program symbols (functions, variables, types, etc.) into the machine code. The result is a fully operational machine code where all the external symbols have been resolved to a numerical memory address.

Low-level (Bas niveau)

Refers to abstraction level, programming style, type of operation, data representation or abstraction that tend to mimick the hardware behavior rather than raising the level of abstraction.

Machine code/language (Code/langage machine)

Program written in the machine language of a given processor, using binary instruction codes for this processor.

Paging (Mémoire paginée)

Physical memory is partitionned into fixed-size pages (e.g., 4KB on x86 by default). Virtual memory translates every page to a distinct virtual address, offering a unified virtual view of memory to processes. Read, write, execute protection can also be configured on each individual page.

Parallelism (Parallélisme)

Simultaneous execution of concurrent operations. Fine-grain parallelism refers to the concurrent execution of individual instructions, small blocks of instructions, or small data vectors. Coarse-grain parallelism refers to the concurrent execution of threads, assuming rare/sparse synchronizations.

Port

16 bit number associated with a sender or receiver socket on a TCP or UDP network connection. The port number allows to differentiate among multiple sockets on a given IP host.

Portable

Applies to an abstraction, an interface, a programming language, a program, an operating system, etc. Qualifies the ability to run, to transpose, to use the qualified object in a different hardware or operating system context.

Process (Processus)

The execution context of a program. It is composed of one or more threads of execution, (virtual) memory pages holding the code and data of the program, and system-related information. The system-related information includes the descriptors of all files opened by the process, its current working directory (CWD), and its current scheduling state.

Register (Registre)

Small amount of storage available on a processor whose contents can be accessed more quickly than storage available elsewhere (like caches or main memory). The size of so-called general-purpose registers defines the bit width of a processor architecture, also called the word size: a 32-bit architecture has 32-bit registers. Special purpose registers may have diffent sizes and dedicated uses, such as vector register, stack registers, etc.

Scheduler/Scheduling (Ordonnanceur/Ordonnancement)

The scheduler decides which resource is assigned to which task. Scheduling decisions can happen at (periodic) controlled times when preemptive or at the discretion of tasks releasing and requesting resources in a collaborative manner. In operating systems, the scheduler is an important part of the kernel in charge of assigning hardware threads to logical, system threads. Only ready system threads are considered by the scheduler; other threads may be stopped by the user, or waiting for a specific event (e.g., an interrupt from a device).

Segmentation

An executable (or binary object) file contains multiple segments: machine code (called text), static initialized data, static uninitialized data (called bss). Some processors also used to segment memory addresses depending to segregate different data types (code versus ordinary data, kernel versus user), this is deprecated in favor of paging, but still supported by x86 processors.

Session

A semi-permanent interactive information exchange between communicating devices during a well-defined pediod of time. For example: TCP and Web (HTTP) sessions (networking), session initiation protocol (SIP) for IP telephony. The operating system also defines a session as a group of processes related to a specific interactive session. For example: processes associated with the login session of a user on a terminal.

Synchronization

Atomic execution of critical sections in threads is a very common case of synchronization, and is some people/languages (Java) abusively refer to atomic execution when talking about synchronization.

Terminal

A computer terminal is a hardware device for (textual) data entry and display; a computer console is a special case whose main purpose is to display administrative messages about the system. A terminal emulator is a program implementing the behavior of a computer terminal; its interface is called a pseudo-terminal. An application interacting through a terminal sees a pseudo-terminal rather than the device in charge of the data entry and display, abstracting away the details of the device I/O and allowing multiple applications to share a single terminal. For example, a graphical terminal application is composed of a pseudo-terminal and of the graphical process in charge of handling key events and displaying text.

Thread of execution (Fil d'exécution)

A thread of execution is a sequence of instructions executing concurrently on multiple processor cores (hardware thread) and/or time-shared on the same processor (system thread). Time-sharing can be preemptive — compulsory alternation among concurrent threads ready to execute — or non-preemptive (collaborative) — each thread yields for another thread to be selected. In both cases, thread selection is peformed by the scheduler of the operating system kernel. Concurrent threads can also be simulated in applications themselves without support from the kernel; they are called user-level threads.