Architecture & OS

🎯 Introduction

Ce chapitre explore le fonctionnement interne d'un ordinateur : comment les données sont représentées en binaire, comment le processeur exécute des instructions, et comment le système d'exploitation gère les processus et la mémoire.

🏗️ Architecture de Von Neumann

Proposée en 1945, cette architecture est à la base de tous les ordinateurs modernes. Elle repose sur 4 composants reliés par des bus :

Cycle d'exécution d'une instruction (Fetch–Decode–Execute)

1. FETCH    : Le PC indique l'adresse de l'instruction en mémoire.
              L'instruction est copiée dans le registre IR.
              PC est incrémenté (pointe sur l'instruction suivante).

2. DECODE   : L'UC décode l'instruction (quel opcode ? quels opérandes ?)

3. EXECUTE  : L'UAL effectue l'opération. Le résultat est stocké
              dans un registre ou en mémoire.

Exemple : ADD R1, R2  →  R1 ← R1 + R2

Les bus

Bus de données    : transporte les données entre CPU et mémoire
Bus d'adresses    : indique où lire/écrire en mémoire
Bus de contrôle   : signaux de lecture/écriture, interruptions...

💻 Représentation binaire

Conversion entre bases

# Décimal → Binaire (divisions successives par 2)
# 42 = 32+8+2 = 101010₂
bin(42)    # → '0b101010'
int('101010', 2)  # → 42  (binaire → décimal)

# Hexadécimal (base 16 : 0-9 puis A-F)
hex(255)   # → '0xff'
int('FF', 16)  # → 255

# 1 octet = 8 bits = 2 chiffres hexa
# 0xFF = 11111111₂ = 255₁₀

Entiers signés : complément à 2

Sur n bits, les valeurs vont de -2ⁿ⁻¹ à 2ⁿ⁻¹ - 1. Sur 8 bits : -128 à +127.

# Représenter -5 sur 8 bits :
# 1. Écrire 5 en binaire : 00000101
# 2. Inverser tous les bits : 11111010
# 3. Ajouter 1 : 11111011 → c'est -5 en complément à 2

# Vérification : 00000101 + 11111011 = 100000000
#                (9 bits, le bit de débordement est ignoré → 0) ✅

# En Python
import struct
struct.pack('b', -5)  # → b'\xfb'  (0xFB = 11111011)

Encodage des caractères

# En Python 3, les str sont Unicode (UTF-32 interne)
ord('A')    # → 65  (code Unicode)
chr(65)    # → 'A'
ord('é')    # → 233

# Encodage en octets
'café'.encode('utf-8')    # → b'caf\xc3\xa9' (5 octets !)
'café'.encode('latin-1') # → b'caf\xe9'     (4 octets)

🐧 Système d'exploitation

Le système d'exploitation (OS) est le logiciel qui fait l'interface entre le matériel et les applications. Il gère les ressources partagées : processeur, mémoire, fichiers, périphériques.

⚙️ Processus et ordonnancement

Un processus est un programme en cours d'exécution. Il possède son propre espace mémoire, ses registres et son compteur programme.

États d'un processus

           fork()           schedulé          fin
  Nouveau ────────► Prêt ───────────► Actif ──────► Terminé
                     ▲                 │
                     │   préempté      │ attend E/S
                     └─────────────────┘
                                       │
                                       ▼
                                    Bloqué
                                (attend ressource)

Ordonnancement

L'ordonnanceur (scheduler) décide quel processus prêt s'exécute. Stratégies courantes :

FIFO (First In, First Out)
  → Simple mais injuste si un processus est très long

Round Robin (tourniquet)
  → Chaque processus a un quantum de temps (ex: 10ms)
  → À la fin du quantum, le suivant prend la main
  → Équitable, temps de réponse garanti

Priorité
  → Chaque processus a une priorité
  → L'ordonnanceur choisit toujours le plus prioritaire
  → Risque de famine pour les processus bas priorité

Interblocage (Deadlock)

Deux processus s'attendent mutuellement indéfiniment car chacun détient une ressource dont l'autre a besoin.

P1 détient R1, attend R2
P2 détient R2, attend R1
→ Deadlock ! Aucun ne peut avancer.

Conditions nécessaires (Coffman, 1971) :
  1. Exclusion mutuelle : une ressource ne peut être utilisée
     que par un seul processus à la fois
  2. Rétention et attente : un processus peut garder ses
     ressources en attendant d'autres
  3. Pas de préemption : on ne peut pas forcer un processus
     à libérer ses ressources
  4. Attente circulaire : P1 attend P2, P2 attend P1...

💾 Mémoire

Hiérarchie mémoire

Mémoire virtuelle

Chaque processus croit avoir accès à tout l'espace d'adressage
(ex: 0 à 2^64 - 1 sur un système 64 bits).

L'OS fait la translation adresse virtuelle → adresse physique
via la MMU (Memory Management Unit).

Pages (généralement 4 Ko) :
- Si la page est en RAM : accès direct
- Si la page est sur disque : "page fault" → chargement (lent !)

🚨 Pièges classiques au bac

📝 Exercices

1. 42 = 32+8+2 = 00101010₂

2. 11001010₂ = 128+64+8+2 = 202₁₀

3. 0xFF = 15×16 + 15 = 255₁₀

4. -7 sur 8 bits :
   7 = 00000111
   Inverser : 11111000
   +1 : 11111001 → c'est -7 ✅
   Vérif : 00000111 + 11111001 = 100000000 (overflow ignoré → 0)

t=0  : P1 s'exécute 2ms → P1 reste 3ms
t=2  : P2 s'exécute 2ms → P2 reste 1ms
t=4  : P3 s'exécute 2ms → P3 reste 2ms
t=6  : P1 s'exécute 2ms → P1 reste 1ms
t=8  : P2 s'exécute 1ms → P2 TERMINÉ à t=9ms
t=9  : P3 s'exécute 2ms → P3 TERMINÉ à t=11ms
t=11 : P1 s'exécute 1ms → P1 TERMINÉ à t=12ms

Résumé :
  P1 : terminé à t=12ms
  P2 : terminé à t=9ms
  P3 : terminé à t=11ms

📌 Fiche synthèse