Système d`exploitation: Une couche de logiciel qui gère le

Système d'exploitation: Une couche de logiciel qui gère le matériel afin d'offrir les services requis par les autres programmes.
Objectifs OS: Ergonomie (gère parallélisme), Efficacité (+débit: gestion ressources, -temps de passage), Évolutif(tailles disquettes, +adressage)
Fonctions OS: Gestion périph. (Interruptions), Gestion des fichiers (Espace, lien nom-adresse, sécurité), Gestion Mem(espace, sécurité), Interface
usager(shell ou fenêtres), Gestion parallélisme(process), Comm entre process(télécom, réseau), Protection et partage(bits de protection,
Comptes usager), Performance(comptabilité, mesure), Utilitaires(librairies math, compilateur, assembleur, éditeur de liens, date/time), Boot

Abstraction des ressources et partage des ressources ||| Offrir machine abstraite aux applic. + Gérer ressources(Driver/Partage/Sécurité)
Niveaux d'abstraction: Humain  Application  OS interface  TrustedOS  Hardware
deamon: user space application qui implémente une fonction de l'OS.
Historique:
Eniac(1950, 200octets, 5k add/s), IBM1401(1960, 16k, disque 10meg@100ms, modem 300cps), Next(1985, 3M)
Évolution: Chargeurs & Bootstrap, IOCS (pilotes), Fichiers, Shell, Monoprogrammation BATCH,
!!!EFFICACITÉ!!!  Parallélisme/process:
ES complexes: canaux (DMA) & interuption, Multiprogrammation, Spooling,
Hiérarchie de mémoire, Mémoire virtuelle, Caches, Multi-tâches interactif (quantum), Systèmes distribués (sockets), JVM
Bootstrap:
Mini-chargeur pour charger le chargeur, maintenant dans le BIOS.
BIOS=Bootstrap+chargeur+IOCS(pilotes)
Parallélisme: ES complexes: canaux (DMA) & interuption, Multiprogrammation, Spooling (politiques!), Hiérarchie de mémoire, Mémoire virtuelle,
Caches, Multi-tâches interactif (quantum), Systèmes distribués, JVM
Multiprogrammation:
Mais (plus de mémoire, plus de périphériques pas partageables)
Besoins(Protection mémoire, Parallélisme [Canaux], Commutation de tâche, Interruptions)
Multiplexage (mémo):
CPUtime, MEMspace
Hardware pour OS: [ protection et efficacité ] DMA, Bootstrap, Protection mémoire (Registres spéciaux),
Instructions privilégiées (mode système/usager), Aide à la commutation (Interruptions), Switch PSW,
Test&Set,
Protection mémoire: Base (RB), Limite (LIM),  Registre M/U (maître/usager) pour les protèger.
Context switching (commutation de tâche): Sauvegarder sur pile (SP:stack pointer), Charger autre...
RB+LIM (système) +CO+SP+... (usager)
Instruction XPSW (...)
version bridée avec PSW source et PSW destination pré-déterminés pour mode usager.
PSW:
Process States Words, (registres critiques, pour le matériel) / PCB: Process Control Block. (descripteur de process, pour le système)
Vecteur d'interruption: Zone mémoire fixe avec un mot par type d'interruption où l'OS doit mettre l'adresse d'une méthode pour la traiter.
Interruptions: E/S (Changement d'état périph. [fin, erreur, ...], Horloge)
Erreurs (Usager [division par 0 / adressage illégal / instruction illégale], Machine [panne, parité])
Note: Trappe ou Supervisor Call (SVC) une des instructions illég. permet demander service (mis code et param. ds registres).
Masquage: registre pour masquer avev un bit par type d'interruption OU 3 modes: Usager / Système / Noyau (Noyau = Système+non-interruptible)
PSW:
État vu du matériel
PCB: [table 6.3]  PSW (...), Ident(PID), Relations(PPID [parent], proprio [UID/GID], enfants+threads), Ressources(mem, fichiers, périph, tampons),
Variables shell ($HOME,$PWD), Comptabilité(priorité, #E/S, tempsCPU, heureDébut), État grossier (Actif/Attente(pkoi), Libre(mort)
Process: Création, Lancement, Mort, Arrêt/Reprise (volontaire[service?] involontaire[fin quantum])
Thread: TCB // Proc léger; partage mem et ressrc, parall ds même proc. // UserThread: illim, si bloque switch PCB | KernelThread: lim, si bl. sw TCB
Synchro: (...) Compétition+Collaboration... Attendre résultat. BUG: instruction atomique!?
Solution d'inhiber interruption pas Ok si + d'un CPU ET perte de temps (attente active) ET besoin instruction privilégiée pour inhiber.
mutex:
mutual exclusion
Sémaphore (Dijkstra 1965): P(wait) V(signal) et INIT Garanties: atomique et ok multiproc.
|| Ne peut en connaître directement la valeur
Producteur – Consommateur:
Lecteur – Rédacteur: (Readers&Writers)
var:
sema msg init 0,
place init n,
mutex init 1;
var:
int NL=0; sema accesBD init 1, accesNL init 1;
prod:cycle
cons:cycle
lire:
écrivain:
--P(msg)
P(accesNL)
P(accesBD)
--P(mutex)
NL++;
<écriture>
<produire>
x  get du tampon
if NL == 1 then P(accesBD)
V(accesBD)
--V(mutex)
V(accesNL)
P(place)
V(place)
--P(mutex)
--<lecture>
<put x dans tampon>
<consommer x>
--V(mutex)
--P(accesNL)
V(msg)
--NL--;
----if NL == 0 then V(accesBD)
end
end
V(accesNL)
Implantation sémaphore:
sema: record
P(s) {
V(s) {
int N;
Label: while lock.TAS() do …;
while lock.TAS() do …;
boolean lock = false;
if N <= 0 {
N++;
end;
lock = false;
lock = false;
goto Label;
}
}
N--;
lock = false;
}
fork&co: fork (copie+go) [pid=fork(); =0 pour fils] // execl et execv (switch sur nouveau code) // system (appel via shell [bloque en attendant retour]
wait: retourne -1 s'il n'y a plus de fils et bloque tant qu'un processus ne sort pas...
waidpid...
fork: 1-Allocation de PCB2 2-Duplication mem usager 3-Copie PCB 4-PCB2  «Prêt» 5-Dispatch
exec:1-Allouer espace pour CODE 2-Charger «p2» 3-Nettoyer DATA 4-Initialiser CO + Stack (SP) 5-Dispatch
write(1, STRING_TO_WRITE, strlen(STRING_TO_WRITE));
char* getenv(const char* name)
int rand(void)
void srand(unsigned int seed)
int pthread_create(pthread_t* thread, pthread_attr_t* attr, void* (*start_routine)(void*), void * arg)
int pthread_join(pthread_t th, void** thread_return)
void pthread_exit(void* retval)
time(NULL): wallclock
clock(): CPU
kill –SIGNAL pid // kill(pid,sig) // void signal( int signum, void (*handler)(int) ) ex.: sigset( SIGINT, handlerINT ); // signal=prochain, sigset=permanent
DIAGRAMME DES ÉTATS GROSSIERS: P.222