Architecture Matérielle

Les langages pouvant être exécutés directement par un ordinateur sont le langage machine et le langage assembleur. Le langage machine est le seul langage directement exécutable, tandis que le langage assembleur utilise des mnémoniques. Les langages réguliers, en compilation, sont ceux qui correspondent aux grammaires régulières.

Un programme qui traduit en même temps qu'il exécute est un programme interprété. Le processus de transformation d'un programme source en assembleur est l'assemblage. La conversion d'un langage de haut niveau en assembleur s'appelle la compilation.

Les raisons pour lesquelles toutes les informations dans un ordinateur sont toujours représentées en binaire sont dues aux caractéristiques des composants physiques, correspondant aux niveaux haut et bas dans les circuits logiques.

Mémoire Principale

La structure de base d'une mémoire principale est :

Registre d'adresse → Mémoire ↔ Registre de données
    ↑       ↑       ↑
    |       |       |
    ————Logique de contrôle temporel———

Le registre d'adresse (MAR) stocke l'adresse d'accès à la mémoire, utilisé pour leadressage, son nombre de bits correspondant au nombre d'unités de stockage. La mémoire stocke les informations binaires. Le registre de données (MDR) stocke temporairement les informations à lire ou à écrire depuis la mémoire. La logique de contrôle temporel génère les signaux de timing nécessaires.

Unité Arithmétique et Logique (UAL)

Effectue des opérations arithmétiques et logiques. Opérations arithmétiques : addition, soustraction, multiplication, division ; opérations logiques : ET, OU, NON, OU exclusif, comparaison, décalage, etc.

Opération	Symbole
Égal à	==
Différent de	!=
Inférieur à	<
Supérieur à	>
Inférieur ou égal à	<=
Supérieur ou égal à	>=
ET	&&
OU	||
NON	!
OU exclusif	^

• && : vrai uniquement si les deux opérandes sont vrais
• || : faux uniquement si les deux opérandes sont faux
• ^ : faux si les opérandes sont identiques

Unité de Contrôle

Unité de contrôle →(Compteur de programme)PC→(Registre d'adresse)MAR→Adresse
↑ | ↑
| | Registre d'état(PSW)←Unité arithmétique et logique(ALU)←Registres généraux(GPRs)
| |                     ↑  |              ↑
| |—————————————————————|——|——————————————|——————————————→(Contrôle de la mémoire principale)
|                          ↓              |
(Registre d'instruction)IR      (Registre de données)MDR—————————

Le PC stocke l'adresse de l'instruction à exécuter. L'IR stocke l'instruction en cours, provenant du MDR. L'opérateur de l'instruction OP(IR) est envoyé à l'unité de contrôle (CU) pour analyse et génération de séquence de micro-opérations ; l'adresse Ad(IR) est envoyée au MAR pour l'adressage des opérandes.

Logiciel

Processus de Travail d'un Ordinateur

• Chargement du programme et des données dans la mémoire principale
• Conversion du programme source en fichier exécutable
• Exécution séquentielle des instructions à partir de l'adresse de début du fichier exécutable

Exemple avec le langage C :

hello.c→(Prétraitement)→hello.i→(Compilateur)→hello.s→(Assembleur)→hello.o→(Éditeur de liens)→hello
                                                      printf_o__↑

Exécution d'Instruction

• Fetch : PC → MAR → M → MDR → IR
• Decode : OP(IR) → CU
• Execute : Ad(IR) → MAR → M → MDR → ACC

Structure Hiérarchique Multiniveau

M4 (Machine de langage de haut niveau) Traduit par un compilateur en langage assembleur
M3 (Machine de langage assembleur) Traduit par un assembleur en langage machine
M2 (Machine de système d'exploitation) Interprété par le système d'exploitation en langage machine
-----------------  Interface logiciel/matériel
M1 (Machine de langage machine) Interprété par microprogramme
M0 (Système de micro-instructions) Exécuté directement par le matériel

Application → Langage de haut niveau → Langage assembleur → Système d'exploitation → Architecture d'ensemble d'instructions → Microcode → Matériel logique

Programmation Stockée

La programmation stockée consiste à entrer les instructions sous forme de code dans la mémoire principale de l'ordinateur, puis à exécuter le programme à partir de son adresse de première instruction. Les instructions suivantes sont exécutées séquentiellement jusqu'à la fin du programme. Selon ce principe, un ordinateur possède cinq fonctions fondamentales : transfert de données, stockage de données, traitement de données, contrôle des opérations et prise de décision.

Vitesse de Calcul

• Débit : nombre de requêtes traitées par le système par unité de temps
• Temps de réponse : délai entre la soumission d'une requête par l'utilisateur et la première réponse du système
• Cycle d'horloge : unité de temps minimale dans un CPU
• Fréquence d'horloge : fréquence de l'horloge principale, inverse de la période du cycle d'horloge
• CPI : nombre de cycles d'horloge nécessaires pour exécuter une instruction
• Temps d'exécution : temps nécessaire pour exécuter un programme
• MIPS : millions d'instructions par seconde
• FLOPS : opérations en virgule flottante par seconde, subdivisé en MFLOPS, GFLOPS, etc.

Données

Systèmes Numériques et Codage

• Binaire : 2^i, où i est le nombre de bits. 2=0000 0010, 4=0000 0100, 8=0000 1000, etc.
• Octal : regroupement de 3 bits binaires. 1111000010.01101 = 001 111 000 010 . 011 010 = 1 7 0 2 . 3 2 = (1702.32) octal
• Hexadécimal : regroupement de 4 bits binaires. 1111000010.01101 = 0011 1100 0010 . 0110 1000 = 3 C (12) 2 . 6 8 = (3C2.68) hexadécimal
• Décimal : (11011.1) binaire = 1x2^4 + 1x2^3 + 0x2^2 + 1x2^1 + 1x2^0 + 1x2^-1 = 27.5 123.6875 = décomposition en facteurs de 2 → (1111011) binaire + 0.6875 × 2 (fraction) → (1111011.1011) binaire

Vraie Valeur et Nombre Machine

Vraie valeur : représentation réelle avec signe "+" ou "-" Nombre machine : "0" représente "+" et "1" représente "-", par exemple 0, 101 = 0101 = +5

Complément à un : X = +101011, [X]comp1 = 00101011 = 00 101011 ; X = -101011, [X]comp1 = 10101011 = 10 101011 Complément à deux : X = -101011, [X]comp1 = 10101011 = 1 0 101011, [X]comp2 = 11010101 = 1 1 010101 (ajout de 1 au complément à un) Décalage : X = -101011, [X]comp2 = 1 1 010101, [X]décalé = 0 1 010101 (inversion du bit de signe du complément à deux)

• Le complément à un est la seule structure de langage que l'ordinateur reconnaisse ;
• Le complément à un inverse tous les bits sauf le bit de signe ;
• Le complément à deux = complément à un + 1 (le bit de signe participe au calcul). Le complément à deux permet d'effectuer des additions/soustractions car l'ordinateur n'a qu'un additionneur, donc a-b devient a+(-b) ;
• Le décalage inverse le bit de signe du complément à deux. Le décalage ne peut représenter que des entiers.

Codes de Contrôle

• Principe de base : ajout de redondance
• Distance de code : nombre minimal de bits différents entre deux codes valides ; La distance entre 1100 et 1101 est 1 (un seul bit différent) ; entre 1001 et 0010 est 3 (trois bits différents).

Distance de code et capacité de détection/correction d'erreurs :

Distance de code d ≥ e+1 : détection de e erreurs Distance de code d ≥ 2t+1 : correction de t erreurs Distance de code d ≥ e+t+1 : détection de e erreurs et correction de t erreurs (e ≥ t)

Méthodes de Contrôle

Parité : ajout d'un bit de contrôle pour vérifier si le nombre de "1" est pair ou impair Code de Hamming : division en groupes avec des bits de parité pour localiser les erreurs Redondance cyclique (CRC) : ajout d'un code de vérification après le code d'information, vérification par division modulo 2

Exemples

1. Codes de parité pour 1001101 et 1010111 En supposant le bit le plus élevé comme bit de parité (Original) 1001101 (Parité impaire) 11001101 (Parité paire) 01001101 (Original) 1010111 (Parité impaire) 01010111 (Parité paire) 11010111
2. Code de Hamming pour 1010 avec n=4, k=3 Soit n le nombre de bits d'information, k le nombre de bits de contrôle, on doit avoir n+k ≤ 2^k -1 (pour détecter deux erreurs, ajouter un bit de contrôle supplémentaire) ; n+k = 7 ≤ 2^3 -1 est vérifié. Soit les bits d'information D4D3D2D1 (1010), les bits de contrôle P3P2P1, le code de Hamming H7H6H5H4H3H2H1

Les Pi sont à la position 2^i-1, les autres sont des bits d'information La distribution est : H7 H6 H5 H4 H3 H2 H1 D4 D3 D2 P3 D1 P2 P1 1 0 1 ? 0 ? ?

D1 est en H3, contrôlé par P2P1 ; D2 est en H5, contrôlé par P3P1 ; D3 est en H6, contrôlé par P3P2 ; D4 est en H7, contrôlé par P3P2P1 ;

=	P1(H1)	+	P2(H2)	+	P3(H4)
3	1		2
5	1				4
6			2		4
7	1		2		4

XOR de tous les bits P1 = D1⊕D2⊕D4 = 0⊕1⊕1 = 0 P2 = D1⊕D3⊕D4 = 0⊕0⊕1 = 1 P3 = D2⊕D3⊕D4 = 1⊕0⊕1 = 0

Le code de Hamming pour 1010 est donc 1010010 (101 0 0 10)

S1=P1⊕D1⊕D2⊕D4 S2=P2⊕D1⊕D3⊕D4 S3=P3⊕D2⊕D3⊕D4

S3S2S1 = 000 signifie pas d'erreur ; ou indique la position de l'erreur.

Mémoire et Stockage

Raisons de la lenteur de la mémoire principale : désynchronisation entre la vitesse de la mémoire et celle du CPU, accès multiples à la mémoire pendant l'exécution des instructions.

Raisons de l'insuffisance de la capacité de la mémoire principale :

• Facteurs technologiques limitant la capacité : spécifications du CPU, carte mère, etc.
• Demande croissante des applications : Windows 98 (8M) → Windows 8 (1G)

※ Structure hiérarchique du stockage : CPU → Cache1 → Cache2 (vitesse) → Mémoire principale → Mémoire auxiliaire (capacité)

Théorie de la structure hiérarchique :

• Localité temporelle : programmes avec structures de boucle
• Localité spatiale : programmes avec structures séquentielles

Mémoires à semi-conducteurs :

• SRAM : vitesse d'accès élevée, intégration faible, consommation élevée, utilisée pour le cache
• DRAM : vitesse d'accès plus lente, intégration élevée, consommation faible, utilisée pour la mémoire principale

Méthodes de rafraîchissement DRAM : rafraîchissement concentré, rafraîchissement distribué, rafraîchissement asynchrone

Extension de capacité mémoire :

• Extension par bit : parallélisation des adresses, sélection de puces et commandes de lecture/écriture, données séparées
• Extension par mot : parallélisation des adresses, données et commandes, décodage de sélection de puce
• Extension par bit et mot : combinaison des deux méthodes

Extension par bit : 8K * 8 bits → 8K * 32 bits Extension par mot : 8K * 8 bits → 32K * 8 bits Extension par bit et mot : 8K * 8 bits → 32K * 32 bits

Sélection de puce :

• Méthode de sélection directe : utilisation des lignes d'adresse haute pour sélectionner directement les puces
• Méthode de décodage de sélection : utilisation d'un décodeur pour générer des signaux de sélection à partir des lignes d'adresse haute

Stratégies d'accélération :

• RAM à double port : deux ports indépendants permettant un accès asynchrone simultané
• Mémoire multi-module :
• Mono-corps multi-mots : lecture parallèle de plusieurs mots, adresses consécutives dans la même unité
• Multi-corps parallèle :
• Croisement haut : adresse haute comme signal, adresse basse comme adresse intra-unité
• Croisement bas : adresse basse comme signal, adresse haute comme adresse intra-unité

Cache

Objectif : résoudre le conflit de vitesse entre la mémoire principale et le CPU

Processus de fonctionnement du cache :

• Données : échange de mots entre CPU et cache, d'entre blocs entre cache et mémoire
• Lecture : hit, miss
• Écriture : stratégie write-through, stratégie write-back

Stratégies d'écriture

• Write-through : écriture simultanée dans le cache et la mémoire, comme si elle traversait le cache. En cas de miss, écriture dans la mémoire principale avec ou sans allocation dans le cache
• Write-back : écriture uniquement dans le cache, avec un bit "dirty" pour indiquer la nécessité d'écriture en mémoire lors du remplacement

Méthodes de mappage

• Mappage direct : bloc de mémoire principale mappé uniquement à une position spécifique dans le cache
• Numéro de ligne de cache = numéro de bloc mémoire % nombre de lignes de cache
• Mappage fully associative : bloc de mémoire principal mappable n'importe où dans le cache
• Numéro de ligne de cache = random(numéro de bloc mémoire)
• Mappage set-associative : division du cache en ensembles, un bloc mappable dans n'importe quelle position d'un ensemble
• Combinaison des deux méthodes. 8 lignes, 1 voie par ensemble = fully associative ; 8 lignes, 8 voies par ensemble = mappage direct

Mécanismes de mappage

• Mémoire associative : l'adresse contient des informations comparables (contenu, position)
• Adresse mémoire = adresse de bloc + déplacement dans le bloc = (Tag + Index) + déplacement dans le bloc
• Structure du cache
• Plusieurs lignes, chaque ligne de taille égale à un bloc mémoire
• Chaque ligne = tag + données + valide + sale

Algorithmes de remplacement

• FIFO (First In First Out) : remplacement du bloc le plus ancien
• LFU (Least Frequently Used) : remplacement du bloc le moins utilisé
• LRU (Least Recently Used) : remplacement du bloc le moins récemment utilisé
• Aléatoire : remplacement aléatoire d'un bloc

Mémoire Virtuelle

Problème résolu : insuffisance de capacité de la mémoire principale. Fournir un espace d'adressage plus grand (supérieur à la mémoire principale) au programmeur Classification :

• Pagination : mémoire divisée en blocs fixes, division physique, fragmentation interne
• Segmentation : taille de bloc variable, division logique, fragmentation externe
• Segmentation-pagination : combinaison des deux, fragmentation interne

Composants :

• Mécanisme de table de pages : récupération d'informations par consultation de table
• Gestion des interruptions : génération d'interruption de page manquante
• Mécanisme de transformation d'adresse : conversion d'adresse logique en adresse physique
• Mémoire et stockage externe : support nécessaire avec une certaine capacité

Implémentation paginée : MMU (Memory Management Unit) + table de pages + TLB (Translation Lookaside Buffer)

Processus de conversion paginée : adresse virtuelle = numéro de page virtuelle + déplacement dans la page ==⟩ numéro de page physique + déplacement dans la page

Système d'E/S (Entrée/Sortie)

Composition : périphériques, interfaces, bus, logiciel de gestion

Fonctions de base :

• Transmission d'informations entre l'ordinateur et l'extérieur
• Sélection correcte des périphériques de sortie par le CPU
• Utilisation de tampons pour adapter les vitesses entre CPU et périphériques

Caractéristiques : asynchrone, temps réel, indépendance du matériel

Processus d'entrée : CPU place l'adresse sur le bus → CPU attend que les données du périphérique soient valides → CPU lit les données depuis le bus et les stocke dans un registre Processus de sortie : CPU place l'adresse sur le bus → CPU place les données sur le bus → le périphérique attend que les données soient valides pour les prendre

Performances du système d'E/S : E/S de stockage, E/S de communication

• Caractéristiques de connexion : quels périphériques peuvent se connecter au système d'E/S
• Capacité du système d'E/S : nombre de périphériques supportés
• Temps de réponse : délai entre la commande utilisateur et le résultat (secondes)
• Débit : nombre d'opérations d'E/S par unité de temps (exprimé en IOP)

Méthodes d'E/S

Méthode d'E/S sans condition : exécution de l'instruction d'E/S avec l'hypothèse que le périphérique est prêt, rarement satisfait

Méthode d'E/S contrôlée par programme : exécution de l'instruction d'E/S après vérification de l'état du périphérique (registre d'état), la décision est prise par le programme

• Les données passent par le CPU, qui perd du temps à interroger l'état du périphérique

Méthode d'E/S par interruption : le périphérique notifie activement le CPU pour recevoir ou envoyer des données, avec caractère temps réel

Méthode DMA : exécution matérielle de l'E/S, après préparation par le périphérique, le DMA prend le contrôle du bus pour échanger les données

• Combine les avantages de l'interruption tout en réduisant la surcharge de service

Méthode de canal et de processeur d'E/S : pour de nombreux périphériques à vitesses très différentes, séparation de la gestion des périphériques du CPU

• Le canal est lui-même un simple CPU qui exécute des instructions d'E/S
• Le processeur d'E/S est une évolution du canal, plus proche d'un CPU

Méthode par Interruption

Concept : interruption du programme en cours par des événements internes ou externes, caractère aléatoire (conforme aux caractéristiques du système d'E/S) Rôles :

• Travail parallèle entre CPU et périphériques d'E/S
• Gestion des pannes matérielles et erreurs logicielles
• Interaction homme-machine, nécessitant des interruptions
• Passage entre programmes multiples, temps partagé, basé sur les interruptions
• Traitement temps réel pour réponse rapide
• Passage entre applications et système d'exploitation (interruption logicielle)
• Communication entre processeurs dans un système multiprocesseur

Schéma de la méthode par interruption :

                          Travail      Terminé                  Travail      Terminé
                  ————————————————————    ————————————————————      ——————————
       Périphérique    ↑                Interr|    ↑  Interr             Interr|   ↑  Interr
                  |                uption| ————— uption             uption| —————uption
CPU               |                Requête↑ |    ↓Retour             Requête↑ |   ↓Retour
                  ——————————————————————    ————————————————————   ————
                  Initialisation               Réponse                     Réponse

Types :

• Interruptions internes (logicielles, exceptions)
• Interruptions externes (masquable INTR, non masquable NMI)

Fonctions de base : Maintien et effacement des signaux d'interruption : stockage dans des registres, effacement après traitement Niveaux de priorité : séquence matérielle de réponse, séquence logicielle de service (masquage au début du programme de service) Identification de la source : attribution d'un identifiant à chaque source (numéro d'interruption)

Gestion des interruptions :

• Réponse : après exécution de chaque instruction, vérification des demandes d'interruption
• Traitement : sauvegarde du point d'interruption (adresse de retour), exécution du programme de service, retour au point d'interruption

Contrôle des interruptions :

• Déclenchement : logique du signal d'interruption (front montant, niveau)
• Ordonnancement : par priorité, tourniquet
• Imbrication : interruption d'un programme d'interruption par un de plus haute priorité, interruptions non masquables non imbriquables
• Masquage : déclencheur dans le processeur, "1" pour réponse aux interruptions externes

Flux de traitement pour interruptions imbriquables :

————————————	  ↓	—————————————————
↑		 Interruption désactivée	↖
|		  ↓		|
|	       Sauvegarde du point d'interruption	|Matériel
|		  ↓		|
|	    Recherche du programme de service	↙
|		  ↓
|	    Sauvegarde du contexte et masquage	↖
Intégration	d'	 Interruption désactivée	|
du		  ↓		|
traitement	Exécution du programme de service	|
des		  ↓		|
interruptions	 Interruption désactivée	|
|		  ↓		|
|	    Restauration du contexte et masquage	|
|		  ↓		|
|		 Interruption activée		|
|		  ↓		|
↓	    Retour d'interruption		↙
——————————————		————————————————

Demande d'interruption : signal envoyé par la source au CPU Priorisation : détermination de la priorité des sources multiples Conditions de réponse :

• Demande d'interruption d'une source
• CPU autorisant les interruptions
• Fin d'exécution d'une instruction sans tâche plus urgente

Instruction implicite : désactivation des interruptions, sauvegarde du point d'interruption, appel du programme de service Vecteur d'interruption : adresse d'entrée du programme de service Traitement : exécution du programme de service, restauration du contexte, retour

Interruptions multiples :

• Concept : nouvelle interruption pendant le traitement d'une interruption, de plus haute priorité
• Conditions :
• Instruction d'activation des interruptions dans le programme de service
• Source de haute priorité peut interrompre une source de basse priorité

Technique de masquage : utilisation d'un masque pour bloquer certaines sources pendant le traitement

Méthode DMA

Principe : transfert de données sans passage par le CPU, effectué par un contrôleur DMA entre mémoire et périphériques, ou entre périphériques

• Compteur d'adresse mémoire : stocke l'adresse des données à échanger
• Compteur de longueur : enregistre la longueur des données à transférer
• Registre tampon : stockage temporaire des données à chaque transfert
• Déclencheur de demande DMA : positionné lorsque le périphérique est prêt
• Logique contrôle/état : circuit de contrôle et de timing, indicateurs d'état
• Gestion des interruptions : déclenchement après transfert complet du bloc

Modes de transfert :

• Arrêt de l'accès CPU : arrêt des accès CPU pendant le transfert
• Accès alterné : division du cycle CPU en parties DMA et CPU
• Cycle volé : utilisation d'un ou plusieurs cycles par le DMA pendant le transfert

Équation de transfert :

• Prétraitement : préparation des registres
• Transfert : utilisation du bus pour transfert de données, entièrement contrôlé par le DMA
• Post-traitement : exécution du programme de service d'interruption pour finaliser

Système d'Exploitation

Caractéristiques de base des systèmes d'exploitation : concurrence, partage, virtualisation et asynchronisme. La concurrence et le partage sont les deux caractéristiques fondamentales, l'une condition de l'autre : le partage des ressources suppose l'exécution concurrente des programmes ; sans exécution concurrente, pas de partage ; sans gestion efficace du partage, l'exécution concurrente est compromise.

Concurrence

La concurrence désigne l'occurrence de deux ou événements dans un intervalle de temps. La concurrence du système d'exploitation signifie la présence simultanée de plusieurs programmes en cours d'exécution. L'introduction du processus vise à permettre l'exécution concurrente des programmes.

• Concurrence : même intervalle de temps
• Parallélisme : même instant

(Un seul cœur peut gérer de nombreuses tâches, mais doit les planifier dans le temps : exécution de la tâche 1 pendant un intervalle, tâche 2 pendant un autre, avec un mécanisme de commutation de contexte. C'est la concurrence) (Plusieurs cœurs peuvent gérer de nombreuses tâches simultanément sans planification, car chaque tâche peut être assignée à un cœur. C'est le parallélisme)

Partage

Le partage des ressources signifie que plusieurs processus en cours d'exécution en mémoire peuvent utiliser les ressources du système. Le partage peut se faire de deux manières.

Exclusion Mutuelle

Pendant une période donnée, une ressource ne peut être utilisée que par un seul programme. Lorsqu'elle est en cours d'utilisation, les autres doivent attendre ; une fois libérée, le système l'attribue selon une stratégie.

Simultané

Pendant la même période, une ressource peut être accédée par plusieurs programmes simultanément. Cette simultanéité est macroscopique ; microscopiquement, l'accès est alterné.

Virtualisation

Techniques de virtualisation : multiplexage temporel (partage du processeur) et multiplexage spatial (mémoire)

Asynchronisme

Dans un environnement d'exécution concurrente, le moment de début, de pause, de progression et de fin de chaque processus est incertain.

Asynchronisme et Synchronisation

La synchronisation est l'exécution séquentielle des processus, avec attente et coordination entre eux ; L'asynchronisme est l'exécution indépendante des processus, où chaque processus continue son travail sans attendre la fin des autres.

Contrôle des Processus

• Processus : processus d'exécution d'une entité de processus, unité indépendante d'allocation et de planification de ressources par le système d'exploitation
• (Les ressources système sont le temps du processeur, de la mémoire et d'autres périphériques alloués à un processus)
• Anatomie du processus : données de gestion P du SE + code en mémoire + données en mémoire + registres généraux R + PSW

États du processus :

(Nouveau) Création→(Prêt)  Planification→ (Exécution)  Fin→(Terminé)
              ↗   ←Fin temps    ↘
          Événement          Attente événement
              ↖             ↙
                  (Bloqué)

• Prêt → Exécution : processus prêt obtient les ressources du processeur (attribution d'une tranche de temps), passe à l'état d'exécution.
• Exécution → Prêt : processus en exécution cède le processeur à la fin de sa tranche de temps. Dans les systèmes préemptifs, un processus de plus haute priorité peut remplacer le processus en cours.
• Exécution → Bloqué : processus demande une ressource (périphérique) ou attend un événement (fin d'E/S), passe à l'état bloqué.
• Bloqué → Prêt : événement attendu se produit, processus passe à l'état prêt.
• Un processus passe de l'exécution au blocage par action propre ; du blocage au prêt par action d'autres processus.

Contrôle des processus :

Soumission------→File d'attente prêt-----→Affectation-----→Processeur------→Terminé
     |                              |
Événement1 |---→File d'attente événement1←---Attente événement1←--|
     |                              |
Événement2 |---→File d'attente événement2←---Attente événement2←--|
     |                              |
Événementn |---→File d'attente événementn←---Attente événementn←--|

Flux de contrôle des processus :

• Création : ajout dans la table des processus, allocation et initialisation du PCB, génération d'identifiant, création de l'image, allocation de ressources, placement dans la file d'attente prêt
• Suppression : retrait de la file, restitution des ressources
• Blocage : sauvegarde du contexte, modification du PCB, placement dans la file d'attente
• Réveil : retrait de la file d'attente, modification du PCB, placement dans la file d'attente prêt
• Suspendre : modification de l'état et déplacement des files, récupération des ressources mémoire
• Réactiver : allocation de mémoire, modification de l'état et déplacement des files

Commutation de contexte et changement de mode :

• Flux : sauvegarde du contexte interrompu, planification du processus, restauration du contexte en cours d'exécution
• Changement de mode : passage de mode utilisateur à mode noyau. La commutation de contexte doit se faire en mode noyau, nécessitant un changement de mode.

Organisation des processus :

• Bloc de contrôle de processus (PCB) : structure de données utilisée par le SE pour enregistrer l'état et les informations d'environnement d'un processus
• Informations d'identification : PID, identifiant de groupe de processus
• Informations de contexte : contenu des registres visibles par l'utilisateur, registres de contrôle/état, pointeur de pile
• Informations de contrôle : informations de planification, composition du processus, pointeurs de file, communication, privilèges, utilisation du processeur, liste des ressources

Threads

• "Processus léger", entité dans un processus, unité de base de planification et d'exécution
• Objectif : améliorer l'exécution concurrente des programmes, augmenter l'utilisation des ressources et le débit du système
• Caractéristiques : plus petite unité d'exécution, ne possède presque pas de ressources système
• Implémentation : threads utilisateur, noyau

-------------------------------------------
|     -----------------------------       |
|     |(Espace utilisateur) (PCB du processus)|      |
|     -----------------------------       |
|              ↑          ↑               |
|                  Partagé                    |
|     -------------     --------------    |
|     | (TCB du thread)|     | (TCB du thread)|    |
|     |           |     |            |    |
|     |  (Pile utilisateur) |     |  (Pile utilisateur) |    |
|     |  (Pile noyau)     |     |  (Pile noyau)     |    |
--------------------------------------------

• Stratégie hybride pour multithreading : un thread utilisateur lié à plusieurs threads noyau

Gestion de la Mémoire (Stockage)

Objectif : support meilleur de l'exécution concurrente de programmes multiples, amélioration des performances

Processus d'exécution d'un programme :

• Compilation : compilation du code source en modules objets par le compilateur
• Édition de liens : liaison des modules objets et bibliothèques par l'éditeur de liens pour former un module chargeable
• Liaison statique : avant l'exécution
• Liaison dynamique au chargement : lors du chargement en mémoire
• Liaison dynamique à l'exécution : lorsque le module est nécessaire
• Chargement : chargement du module en mémoire par le chargeur
• Chargement absolu : pour environnement monoprogrammé
• Relocalisation statique : pour mémoire immobile après chargement
• Relocalisation dynamique : pour mémoire mobile, conversion à l'exécution avec matériel

Conversion d'adresse : adresse logique → adresse physique Espaces d'adressage :

• Espace d'adressage logique : ensemble des adresses relatives utilisées par un programme après compilation/édition de liens
• Espace d'adressage physique : ensemble des unités physiques de mémoire

Adresse logique : adresse utilisateur, commençant à zéro

• Adresse logique unidimensionnelle : (adresse)
• Adresse logique bidimensionnelle : (numéro de segment : déplacement dans le segment)

Protection mémoire :

• Registres de limite supérieure et inférieure : comparaison avec les registres correspondants
• Registres de base et de longueur : comparaison avec la longueur, ajout de la base

Allocation Continue

Allocation unique continue : allocation dans une zone fixe de mémoire, adaptée aux systèmes monoprogrammés, division en zone système et utilisateur, relocalisation statique Allocation par partitions fixes : allocation dans différentes zones fixes, partitions égales ou inégales, avec table d'allocation, fragmentation interne Allocation par partitions dynamiques :

• Concept : division dynamique selon les besoins du programme, allocation dynamique d'espace mémoire, fragmentation externe

Algorithmes d'allocation par partitions dynamiques :

• Premier ajustement : recherche séquentielle de la première partition suffisante
• Meilleur ajustement : recherche de la plus petite partition suffisante
• Pire ajustement : recherche de la plus grande partition suffisante
• Prochain ajustement : comme premier ajustement, mais à partir de la position de fin de recherche précédente

Allocation Non Continue (Gestion paginée)

Concept :

• Mémoire principale divisée en cadres, programme divisé en pages.
• Différentes pages de programme peuvent être placées dans différents cadres non consécutifs.
• La relation entre pages et cadres est maintenue par la table de pages.
• La bitmap indique l'allocation de la mémoire principale, la table de pages du processus maintient l'intégrité logique.

Adresses :

• Adresse logique : numéro de page + déplacement
• Adresse physique : numéro de cadre + déplacement

Table de translation rapide (TLB) :

• Utilisation du cache pour stocker une partie de la table de pages
• Technologie de mémoire associative, avec stratégie d'éviction comme pour le cache

Algorithmes de pagination :

• Pagination de base : mémoire divisée en blocs fixes, division physique, fragmentation interne
• Segmentation de base : taille de bloc variable, division logique, fragmentation externe
• Segmentation-pagination : combinaison des deux, fragmentation interne

Mémoire virtuelle paginée :

• Table de pages : indicateur + numéro de cadre mémoire + adresse de stockage auxiliaire

Implémentation :

• Consultation de la table de pages : si la page est en mémoire, génération de l'adresse absolue
• Si absente, interruption de page manquante
• Le SE répond à l'interruption : si cadre mémoire disponible, chargement depuis stockage auxiliaire, mise à jour des tables
• Si aucun cadre disponible, remplacement de page puis chargement

La mémoire virtuelle utilise la même méthode que la mémoire de stockage

Unité de gestion mémoire (MMU)

Rôle : matériel de gestion de la mémoire virtuelle, conversion d'adresse virtuelle en physique, protection mémoire, éviction de pages si nécessaire Implémentation : utilisation d'une structure de données - table de pages inversée (IPT)

        Adresse logique                                Adresse physique
    -----------------                        -----------
    |ID processus|numéro page|déplacement|        |numéro cadre|déplacement|
    -----------------                        -----------
         |     |   |                             ↑    ↑
    -----------┙   └-----------------------------------
    |                   ID processus numéro page indicateur pointeur    |
    ↓                  -----------------------   |
 Hachage--→Table de hachage----→|                       |→Index
                       -----------------------
                              Table de pages inversée

Gestion de Fichiers

Organisation des fichiers :

• Structure logique : fichiers flux (sans structure), données organisées séquentiellement
• Structure physique : fichiers enregistrés (avec structure)
• Fichiers séquentiels : blocs consécutifs, fichiers par lots et système. ---⟩ tableau
• Fichiers chaînés : pointeur vers le prochain bloc. ---⟩ liste chaînée
• Fichiers directs : hachage du contenu vers position physique. ---⟩ table de hachage
• Fichiers indexés : table d'index pour le fichier, pouvant être multi-niveaux. ---⟩ liste chaînée avec table de hachage

Structure de répertoires :

• Mono-niveau : tous les fichiers dans un seul répertoire
• Bi-niveaux : répertoires utilisateur sous un répertoire principal
• Multi-niveaux : extension du bi-niveau en structure arborescente
• Sans cycle : arbre avec arêtes orientées pour partage

Partage de fichiers :

• Par nœud d'index (lien dur) : partage指向 le même nœud d'index, exemple : ln /usr/bin/gcc /opt/test/gcc-hard
• Par lien symbolique (lien souple) : stockage du chemin du fichier partagé, exemple : ln -s /usr/bin/gcc /opt/test/gcc-soft

Modes d'accès aux fichiers : séquentiel, direct, indexé Contrôle des fichiers : contrôle logique, contrôle physique Utilisation des fichiers : ouvrir, fermer, lire, écrire, contrôler

Stockage des fichiers :

• Bloc : zone de stockage continue sur le support, unité d'échange entre mémoire et stockage auxiliaire
• Périphériques d'accès séquentiel : CD, bande magnétique
• Périphériques d'accès direct : disque

Allocation par Index

Chaque fichier a un bloc d'index contenant tous les numéros de blocs du fichier.

Chaque fichier a un bloc d'index, qui est un tableau d'adresses de blocs disque.

La i-ème entrée du bloc d'index pointe vers le i-ème bloc du fichier. L'entrée de répertoire contient l'adresse du bloc d'index.

Pour lire le i-ème bloc, on utilise la i-ème entrée du bloc d'index pour trouver et lire le bloc requis.

Création de fichier : toutes les entrées du bloc d'index sont initialisées à vide. Premier écriture du i-ème bloc : allocation d'un bloc libre, écriture de son adresse dans la i-ème entrée. L'allocation par index supporte l'accès direct et n'a pas de fragmentation externe.

L'inconvénient est l'augmentation de l'espace de stockage pour les blocs d'index. La taille du bloc d'index est importante : chaque fichier doit en avoir un, donc il doit être petit, mais trop petit ne supporte pas les gros fichiers.

Solutions :

• Chaînage : plusieurs blocs d'index chaînés
• Indexation multi-niveaux : premier niveau pointe vers des blocs d'index secondaires, etc. Par exemple, bloc de 4096B avec 1024 pointeurs de 4B permet des fichiers jusqu'à 4GB avec deux niveaux.
• Indexation hybride : combinaison de méthodes, comme adresses directes, index simple ou double.

Implémentation de l'indexation hybride

Utilisée dans UNIX. Dans le nœud d'index de System V, 13 entrées d'adresse sont définies (iaddr(0)~iaddr(12)). Dans BSD UNIX, également 13 entrées, divisées en adresses directes et indirectes.

(1) Adresses directes Pour accélérer la recherche, 10 entrées d'adresse directe sont définies dans le nœud d'index (iaddr(0)~iaddr(9)), stockant directement les numéros de blocs. Si chaque bloc fait 4KB, un fichier ≤40KB peut être entièrement lu depuis le nœud d'index.

(2) Adresse indirecte simple Pour les gros fichiers, utilisation de iaddr(10) pour adresse indirecte simple. C'est une allocation à un niveau. Le bloc indirect simple contient 1024 numéros de blocs, permettant des fichiers jusqu'à 4MB.

(3) Adresses indirectes multiples Pour les fichiers >4MB+40KB, utilisation de l'adresse indirecte double (iaddr(11)). C'est une allocation à deux niveaux, permettant des fichiers jusqu'à 4GB. De même, iaddr(12) comme adresse indirecte triple, jusqu'à 4TB.

Gestion des E/S (Entrée/Sortie)

Méthodes de Contrôle

Évolution : interrogation → interruption → DMA → canal E/S Architecture classique : pont nord/sud

Implémentation

Niveaux d'implémentation logiciel : matériel → programme de gestion d'interruption → pilote de périphérique → logiciel indépendant du périphérique → logiciel E/S en espace utilisateur

• Logiciel E/S utilisateur : interface avec l'utilisateur
• Logiciel d'indépendance périphérique : interface uniforme entre programme utilisateur et pilotes, commandes périphériques, protection, allocation
• Pilote de périphérique : lié au matériel, implémentation des commandes du système
• Programme de gestion d'interruption : traitement des interruptions
• Matériel : composant mécanique (périphérique) et électronique (contrôleur)

Tamponnage E/S :

• Problèmes résolus :
• Désynchronisation vitesse CPU/périphérique
• Incohérence taille enregistrement logique/physique
• Réduction du nombre d'interruptions CPU
• Implémentation : zone tampon
• Zone en mémoire pour stockage temporaire des données d'E/S
• Classification : tampon simple, double, multiple

Gestion du Démarrage et des Services

Processus de Démarrage Linux

1. Auto-test POST du BIOS, chargement du disque dur.
2. Lecture du MBR, amorçage MBR.
3. Menu de démarrage Grub (Chargeur de démarrage).
4. Chargement du noyau kernel.
5. Démarrage du processus init, configuration des niveaux d'exécution via inittab.
6. Processus init, exécution du fichier rc.sysinit.
7. Chargement des modules noyau, exécution des scripts des différents niveaux.
8. Exécution de /etc/rc.d/rc.local.
9. Démarrage des tty, interface de connexion.

※ RHEL 5 : SysVinit, RHEL 6 : Upstart, RHEL 7 : Systemd

/etc/inittab (fichier inittab)

Après le démarrage du noyau Linux, le premier processus utilisateur (init) est lancé pour démarrer les autres processus ou services. Init est donc le père de tous les processus. Init analyse le fichier inittab, exécute les scripts de configuration et initialise le système.

# Structure suivante
identificateur:niveau_d_exécution:action:processus

• id : identifiant unique pour chaque entrée, non répétitif
• runlevels : niveaux d'exécution où l'action s'applique, plusieurs niveaux possibles sans séparateur ; vide pour tous les niveaux
• action : action à exécuter sous certaines conditions
• process : programme ou script à exécuter

si::sysinit:/etc/rc.d/rc.sysinit

• id "si" est un identifiant
• runlevels vide : application à tous les niveaux d'exécution
• sysinit : exécution au démarrage du système
• /etc/rc.d/rc.sysinit : script d'initialisation système

Tableau des actions :

Action	Effet
respawn	init doit surveiller ce processus et le redémarrer s'il se termine
wait	init exécute une fois ce processus et attend sa fin
once	init exécute une fois ce processus
boot	init exécute ce processus au démarrage du système
bootwait	init exécute ce processus au démarrage et attend sa fin
ctrlaltdel	exécution lorsque Ctrl+Alt+Del est pressé, envoi de SIGINT à init
sysinit	exécution avant boot ou bootwait
powerfail	exécution lorsque init reçoit SIGWR
powerokwait	exécution lorsque SIGWR est reçu et que /etc/powerstatus contient OK
powerwait	exécution lorsque SIGPWD est reçu et init attend la fin

Dans l'initialisation System V traditionnelle, /etc/inittab est crucial. Au démarrage, init recherche inittab pour initialiser le système, définir les niveaux d'exécution et exécuter les commandes correspondantes. Si le niveau par défaut est 5, init exécute /etc/init.d/rc5, qui exécute les scripts de /etc/rc5.d selon les dépendances. Dans /etc/rc5.d, les fichiers sont des liens symboliques vers /etc/init.d/ ; les "S" indiquent le démarrage, les "K" l'arrêt, les nombres indiquent l'ordre.

Niveaux d'exécution

1. Arrêt (ne jamais définir initdefault à 0)
2. Monoutilisateur
3. Multi-utilisateur, sans NFS
4. Multi-utilisateur complet (niveau standard)
5. Réservé
6. X11 (fenêtre X)
7. Redémarrage (ne jamais définir initdefault à 6)

init.d et service

/etc/init.d contient les scripts utilisés par l'outil d'initialisation System V (SysVinit), package traditionnel de gestion de services Linux, contenant le processus init (premier processus après noyau) et l'infrastructure de démarrage/arrêt de services. Les fichiers dans /etc/init.d sont des scripts shell répondant aux commandes start, stop, restart et (si supporté) reload. Ils peuvent être déclenchés par d'autres mécanismes (généralement des liens symboliques dans /etc/rcX.d).

/etc/init contient les fichiers de configuration utilisés par Upstart. Upstart est un package plus jeune de gestion de services, initié par Ubuntu. Les fichiers dans /etc/init sont des fichiers de configuration indiquant comment et quand démarrer, arrêter, recharger ou interroger l'état d'un service.

/etc/rc.d contient :

• /etc/rc.d : rc.local, rc.sysinit, init.d, rcX.d (X=0-6 pour les niveaux)
• /etc/rc.d/init.d : scripts de gestion de services système, /etc/init.d est un lien vers ce répertoire
• /etc/rc.d/rcX.d : scripts avec "K" pour arrêt (STOP), "S" pour démarrage (START), les nombres indiquent l'ordre d'exécution
• /etc/rcX.d est un lien symbolique, mais les fichiers pointent vers /etc/rc.d/init.d
• /etc/rc.d/rc.local : script exécuté après les scripts rcX.d, ajout de commandes à exécuter à tous les niveaux

Ordre d'exécution Red Hat :

1. Chargement du noyau
2. Exécution de init
3. /etc/rc.d/rc.sysinit # premier script exécuté par init
4. /etc/rc.d/rc $NIVEAU # $NIVEAU est le mode par défaut
5. /etc/rc.d/rc.local
6. /sbin/mingetty # attente de connexion utilisateur

Étape 3 : rc.sysinit effectue principalement :

1. Chargement du keymap et des polices
2. Activation du swapping
3. Définition du nom d'hôte
4. Définition du domaine NIS
5. Vérification (fsck) et montage des systèmes de fichiers
6. Activation des quotas
7. Chargement des modules son
8. Configuration de l'horloge système, etc.

Étape 4 : /etc/rc.d/rc $NIVEAU exécute les scripts correspondants selon le mode.

• Les scripts "Kxx" tuent les processus (arrêt), les "Sxx" les démarrent, l'ordre croissant des nombres.
• Par exemple, avec le mode 3 par défaut, /etc/rc.d/rc exécute les scripts de /etc/rc3.d/. Red Hat exécute rc.local après tous les scripts d'initialisation, permettant d'ajouter des commandes supplémentaires. Typiquement pour monter des systèmes de fichiers NFS ou des scripts de débogage.

service est une commande d'exécution de scripts pour SysVinit, située dans /etc/init.d. La commande service analyse et exécute les programmes correspondants dans ce répertoire.

systemd et systemctl

systemd remplace initd avec :

1. Démarrage plus rapide : init exécute séquentiellement, systemd parallélise.
2. Scripts simplifiés : systemd gère plus que l'exécution de scripts.

systemd inclut un System and Service Manager, exécuté en tant que PID 1, responsable du démarrage d'autres programmes. Fonctionnalités :

• Exécution parallèle des tâches ;
• Activation des services par socket et D-Bus ;
• Démarrage à la demande des démons ;
• Surveillance des processus via cgroups Linux ;
• Prise de vue et restauration du système ;
• Gestion des points de montage et d'automontage ;
• Groupe de processus (Slice) ;
• Conteneurs et machines virtuelles ;
• Configuration réseau, synchronisation temporelle, résolution de noms.

systemd supporte les scripts d'initialisation SysV et LSB, peut remplacer sysvinit. De plus, il gère les journaux, la configuration système, les comptes utilisateurs, les répertoires d'exécution, la gestion réseau, etc.

Commandes : Linux Memo (services système/systemctl)

Unité

Concept de base : À l'initialisation, différents services système et utilisateur doivent être démarrés. Systemd appelle Unité toutes les ressources gérées, avec 12 types :

Service Unit : services système
Target Unit : composition de plusieurs Unités
Device Unit : matériel
Mount Unit : points de montage
Automount Unit : automontage
Path Unit : chemins et fichiers
Scope Unit : processus non démarrés par Systemd
Slice Unit : groupe de processus
Snapchat Unit : instantané Systemd
Socket Unit : sockets de communication
Swap Unit : fichier de swap
Timer Unit : minuteurs

Fichiers de configuration des Unités : Chaque Unité a un fichier de configuration dans /etc/systemd/system/ (lien symbolique vers /usr/lib/systemd/system/). Les noms de fichiers ont l'extension du type d'Unité, .service par défaut.

1. Format de fichier Texte éditable, divisé en sections [Unit], [Service], [Install], avec paires clé=valeur.

[Unit]
Description=Description
[Service]
Type=forking
ExecStart=/usr/bin/sshd
[Install]
WantedBy=multi-user.target

2. Sections [Unit] : métadonnées de l'Unité, relations avec d'autres Unités :

Description : description
Documentation : liens vers documentation
Requires : Unités nécessaires, sinon échec
Wants : Unités associées, pas d'échec si absentes
BindsTo : comme Requires, mais sortie de l'Unité liée arrête l'actuelle
Before : doit démarrer après les Unités spécifiées
After : doit démarrer avant les Unités spécifiées
Conflicts : ne peut coexister avec l'Unité spécifiée
Condition... : conditions pour démarrage
Assert... : conditions pour démarrage, sinon échec

[Install] : définition du démarrage et du démarrage automatique :

WantedBy : valeur ou plusieurs cibles, activation crée des liens symboliques dans /etc/systemd/system/ avec .wants
RequiredBy : valeur ou plusieurs cibles, activation crée des liens avec .required
Alias : alias pour démarrer l'Unité
Also : autres Unités activées simultanément

[Service] : configuration spécifique aux services :

Type : comportement au démarrage (simple, forking, oneshot, dbus, notify, idle)
ExecStart : commande de démarrage
ExecStartPre : commande avant démarrage
ExecStartPost : commande après démarrage
ExecReload : commande de redémarrage
ExecStop : commande d'arrêt
ExecStopPost : commande après arrêt
RestartSec : délai avant redémarrage automatique
Restart : conditions de redémarrage (always, on-success, etc.)
TimeoutSec : délai avant arrêt forcé
Environment : variables d'environnement

Cible (Target)

Une Cible est composée de plusieurs Unités, le démarrage d'une Cité lance plusieurs Unités. À l'initialisation, il suffit de démarrer une Cible.

systemctl list-unit-files --type=target  # lister toutes les cibles
systemctl list-dependencies multi-user.target # lister les Unités d'une cible
systemctl get-default  # voir la cible par défaut

Journaux

Systemd gère tous les journaux (noyau et applications) avec journalctl. La configuration est dans /etc/systemd/journald.conf.

POSIX

POSIX (Portable Operating System Interface) est un ensemble de standards pour l'interface entre les logiciels et les systèmes d'exploitation. Il définit les API, les shells et les interfaces de commande pour assurer la portabilité des logiciels entre différents systèmes UNIX.

Les standards POSIX couvrent :

• Systèmes de fichiers
• Gestion des processus
• Communication inter-processus
• Terminal I/O
• Multi-threading
• Communications réseau

L'implémentation POSIX permet aux développeurs d'écrire des applications portables entre différents systèmes d'exploitation compatibles POSIX.