systèmes d'exploitation - bde ensicaenlefebvre/cours/cours_ser.pdf · années 60, premiers os...

1

Réseaux et systèmes embarquéssystèmes d'exploitation

Philippe LEFEBVRE

2

Systèmes d'exploitations et réseaux

Plan

Ensicaen – Ph Lefebvre

ch 0 - Introduction

● Systèmes d'exploitations– Le multi-tâche (3h)– La gestion de la mémoire (1,5h)– La gestion des entrées-sorties (1,5h)

● Les réseaux : – Le modèle OSI, les méthodes d'accès (3h)– IP et TCP/UDP (4,5h)– Les réseaux de terrains (9h)

3


Bibliographie


ch 0 - Introduction

● A. Silberschatz, P. Galvin – Operating System concepts● A. Tanenbaum - Architecture des ordinateurs● P. Ficheux – Linux embarqué● A. Rubini, J. Corbet – Linux Device Driver● http://rangiroa.essi.fr/cours/● Polycopiés Hafid BOURZOUFI, MC Univ Valenciennes● Polycopiés P Nugues - Ensicaen● G. Pujolle - Les réseaux

http://rangiroa.essi.fr/cours/

4


Introduction


ch 0 - Introduction

Système d'exploitation :

● Programme dont le rôle est de gérer le matériel● Permet de lancer les programmes des utilisateurs● Plus qu'un simple moniteur● Plus que le BIOS● Offre une couche d'abstraction vis à vis du matériel● Gestion des fichiers, de la mémoire, du réseau, du multi-tâche, de l'lHM...

5

Systèmes d'exploitations et réseaux Ensicaen – Ph Lefebvre

ch 0 - Introduction

Système d'exploitation :

● Années 60, premiers OS sur des mainframes : traitement par lot, temps partagé

● Années 70, Unix : multi-utilisateur, réseau● Années 80 et 90, PC : interactivité, plug & play● Années 2000, OS embarqués : PDA, téléphones portables...

Mais aussi : Internet, systèmes distribués, systèmes temps réels, multiprocesseurs...

Dans des ordinateurs, mais aussi dans des voitures (environs 60 CPU / voiture) , appareil photo, routeur ADSL, chaîne HIFI...

6


ch 0 - Introduction

Quelques OS

● Unix , Linux● Windows NT, 2000, XP, ● MAC OS X● Windows CE, pocket PC● Palm OS● RT-Linux, uCLinux, ecos...● VxWorks, pSos● JavaOS, TINI-OS

7


Ch 1 - Le multi-tâche


ch 1 – Le multi-tâche

Plan

● L'implantation en mémoire● Ordonnancement des processus ● Les processus légers : les threads● La synchronisation des tâches : les sémaphores, les blocs synchronisés.● Communications inter Processus

8



Définitions :● Un processus est l'entité d'exécution dans un système ● Un processus = un programme en cours d'exécution

Composants d'un processus● le code : programme ● les données : variables globales et dynamiques

(appelé aussi tas)● La pile d'exécution : variables locales, mise en oeuvre

des appels et retour des fonctions● Le contexte : les registres internes (IP, SP... ), la table

des fichiers ouverts, les variables d'environnement comme errno, CLASSPATH...

Pile

Tas

Code

La pile et le tas ont des frontières mobiles qui croissent en sens inverse.

9



Exemple de représentation mémoire pour un processeur Intel. - voir la traduction assembleur page suivante -

EAX : accumulateurEBP : Base Pointer : pointe le début de la pile au moment de l'entrée dans une fonctionESP : Stack Pointer : pointeur de pile

main() {

int a=7 ; printf (" 2 x %d = %d\n", a, fois2(a));

}int fois2 (int b) { return (b*2);}

La variable locale a sera à l'adresse contenue dans EBP – 8 octetsLe paramètre b sera à l'adresse contenue dans EBP – 8 octets ( EBP n'aura pas la même valeur)Par convention le code de retour d'une fonction se trouve dans EAXC'est l'appelant qui dépile les paramètres qu'il a empilé pour un appel de fonction. Les constantes (ici la chaîne de caractère du printf) sont stockées dans le code.

10



> gcc -S essai.c> more essai.s .file "essai.c" .section .rodata.LC0: .string " 2 x %d = %d\n" .text.globl main .type main, @functionmain: leal 4(%esp), %ecx andl $-16, %esp pushl -4(%ecx) pushl %ebp movl %esp, %ebp pushl %ecx subl $36, %esp movl $7, -8(%ebp) movl -8(%ebp), %eax movl %eax, (%esp) call fois2 movl %eax, 8(%esp) movl -8(%ebp), %eax movl %eax, 4(%esp)

movl $.LC0, (%esp) call printf

addl $36, %esp popl %ecx popl %ebp leal -4(%ecx), %esp ret .size main, .-main.globl fois2 .type fois2, @functionfois2: pushl %ebp movl %esp, %ebp movl 8(%ebp), %eax addl %eax, %eax popl %ebp ret .size fois2, .-fois2 .ident "GCC: (GNU) 4.2.4

(Ubuntu 4.2.4-1ubuntu3)" .section .note.GNU-

stack,"",@progbits

11



États d'une tâche

12



États d'une tâche (suite)

● Nouveau : le processus est en cours de création ● En exécution (Running) : les instructions sont en cours d'exécution par le CPU● En attente (Sleep) : le processus attend qu'un événement se produise

➢ événement : un signal, terminaison d'une E/S, libération d'une ressource...● Prêt (Ready) : le processus attend d'être affecté au CPU● Terminé : le processus a fini son exécution

13



Bloc de contrôle de processus

Chaque processus est représenté dans le SE par un bloc de contrôle (Process Control Bloc : PCB )

Composants d'un PCB :● l'état du processus : nouveau, prêt, en exécution● le compteur d'instructions : prochaine instruction à exécuter● les registres du CPU● Date de création du processus● informations sur son numéro (PID) ● informations sur le répertoire de travail● informations de l'identité de l'utilisateur, de son groupe (UID, GID)● informations sur l'état des E/S (ex : liste des fichiers ouverts)● etc...

14



Commutation de contexte, d'un processus à un autre.

15



Ordonnancement

Quel processus choisir dans la file d'attente des processus prêts ?

Un bon algorithme doit être capable de :● s'assurer que chaque processus reçoit sa part du temps CPU : équité● Gérer correctement les priorités s'il y en a. ● utiliser le temps processeur à 100% : efficacité ● minimiser le temps de réponse en mode interactif : temps de réponse ● minimiser le temps d'attente en traitement par lots : temps d'exécution ● maximiser le nombre de travaux effectués en une heure : rendement

16



Types d'ordonnancement

● Ordonnancement sans réquisition, type 1– Exécution jusqu'à terminaison d'un processus – adapté aux systèmes à traitement par lot – non adapté aux systèmes interactifs et multi-utilisateurs

● Ordonnancement sans réquisition, type 2 (Collaborative Scheduling)– Exécution jusqu'à ce qu'un processus "passe la main"– oblige le développeur à insérer des yield() (windows 3.11, le code MSDOS

dans win9x)

● Ordonnancement avec réquisition (Preemptive Scheduling) : OS modernesSuspension du processus en exécution par :– appels systèmes (points de préemption dans le code de la fonction)– interruptions matérielles (prioritaires)– expiration du quantum de temps (IT d'un timer armé par l'OS)

17



Algorithmes d'ordonnancement

Méthode du tourniquet.

Les processus prêts se succèdent et sont exécutés sur le CPU pendant un quantum de temps calculé en fonction de la charge du système. L'OS assure le changement de contexte entre 2 quotas de temps.

Durée du quantum ? ● Un quantum trop petit provoque trop de commutations de processus. Le changement de contexte devient coûteux.● Un quantum trop élevé augmente le temps de réponse

P2OS

OS

OSP4

P3

OS

P1

temps

CPU

18



Algorithmes d'ordonnancement (suite) Par file de priorité Les processus prêts de forte priorité s'exécutent d'abord Lorsque la file d'une priorité est vide on passe à la file de priorité inférieure A l'intérieur d'une file on peut utiliser l'algorithme du tourniquet. Si un process de basse priorité utilise une ressource utile à un process de haute

priorité, l'ordonnanceur peut « inverser » les priorités pour libérer la ressource.

process 1 process 2 (fin) process 1(fin)

process 3 process 3

temps

priorité

process 3 interrompu par process 1de plus haute priorité

19



Les processus sur UNIX

Un processus peut se dupliquer – et donc ajouter un nouveau processus – par la fonction :

pid_t fork(void)qui rend -1 en cas d’échec. En cas de réussite, la fonction retourne 0 dans le processus fils et le n° du processus fils – Process Identifier ou PID – dans le père. Cette fonction transmet une partie du contexte du père au fils : les descripteurs des fichiers standards et des autres fichiers, les redirections… Les deux programmes sont sensibles aux mêmes interruptions. À l’issue d’un fork() les deux processus s’exécutent simultanément.

main() {int pid = fork() ; // création du deuxième processusif (pid == 0) { // portion de code exécuté uniquement par le processus fils}else { // portion de code exécuté uniquement par le processus père }// puis code exécuté par les 2

}

20




La création d’un nouveau processus ne peut se faire que par le recouvrement du code d’un processus existant grâce à la fonction :

int execl(char *ref, char *arg0, char *argn, 0) ref est une chaîne de caractères donnant le nom et le chemin du nouveau

programme à substituer et à exécuter. arg0, arg1, …, argn sont les arguments du programme. Le premier argument, arg0, reprend en fait le nom du programme.

Les fonctions execle() et execlp() ont des arguments et des effets semblables. Les fonctions int execv(char *ref, char *argv[]) ainsi que execve()

et execvp() sont aussi des variantes analogues.

Ces fonctions rendent -1 en cas d’échec.

21



Les processus sur UNIXexemple :

void main(){

execl("/bin/ls", "ls", "-l", (char *) 0);printf("Cette instruction ne sera pas exécutée\n");

}La création d’un nouveau processus – l’occupation d’un nouvel emplacement de la table des processus – implique donc la duplication d’un processus existant. Ce dernier sera le père. On substituera ensuite le code du fils par le code qu’on désire exécuter. Au boot de la machine, le processus initial (init)lance tous les processus utiles au système.

22



Les processus sur UNIXTerminaisonUn processus se termine lorsqu’il n’a plus d’instructions ou lorsqu’il exécute la fonction :

void exit(int statut) ;

L’élimination d’un processus terminé de la table ne peut se faire que par son père, grâce à la fonction :

int wait(int *code_de_sortie)

Avec cette instruction, le père se bloque en attente de la fin d’un fils. Elle rendra le n° PID du premier fils mort trouvé. La valeur du code de sortie est reliée au paramètre d’exit de ce fils. On peut donc utiliser l’instruction wait pour connaître la valeur éventuelle de retour, fournie par exit(), d’un processus. Ce mode d’utilisation est analogue à celui d’une fonction. wait() rend -1 en cas d’erreur.

23




Les signaux

int kill(int pid, int signal)

permet à un processus d’envoyer un signal à un autre processus. pid est le n° du processus à détruire et signal, le n° du signal employé. La fonction kill correspond à des interruptions logicielles.Par défaut, un signal provoque la destruction du processus récepteur, à condition bien sûr, que le processus émetteur possède ce droit de destruction.

kill() rend 0 en cas de succès et -1 en cas d’échec.

24



Quelques signaux


Nom du signal N° du signal CommentairesSIGUP 1 signal émis lors d’une déconnexionSIGINT 2 ^CSIGQUIT 3 ^\SIGKILL 9 signal d’interruption radicaleSIGALRM 14 signal émis par alarm(int sec) au bout de sec secondesSIGCLD 20 signal émis par un fils qui se termine, à son père

25




Handler

Un processus peut détourner les signaux reçus et modifier son comportement par l’appel de la fonction :

void *signal(int signal, void (*fonction)(int)))

fonction peut prendre les valeurs suivantes :SIG_IGN le processus ignorera l’interruption correspondanteSIG_DFL le processus rétablira son comportement par défaut lors de l’arrivée de l’interruption (la terminaison)void fonction(int n) Le processus exécutera fonction, définie par l’utilisateur, à l’arrivée de l’interruption n. Il reprendra ensuite au point où il a été interrompu

26




Timer

La fonction alarm (int tps) permet d'armer un timer de tps secondes. A l'issu de ce temps, un évènement de type SIGALRM sera envoyé au processus.

Exemple :void ma_fonc (void *p) {

printf (" tps = %d", time(NULL));alarm(1);

}main () {

signal (SIGALRM, ma_fonc) ;alarm (1) ;while(1);

}

27



Les processus légers - threads

Processus :- lourd en mémoire (duplication du code)- communication entre processus difficile (segments séparés).

Les processus légers ou threads :- Dans un même processus, plusieurs threads- Code, contexte et tas sont partagés- Autant de piles que de threads- A chaque thread est affecté un PCB réduit permettant la sauvegarde des

registes.

Exemple :Traitement de textes : un thread pour la correction en ligne, un autre pour la

mise en page, un autre pour la saisie...

28



● On peut attendre la terminaison d'un thread en appelant sa méthode join() : dans ce cas l'appelant est bloqué.

● Un thread peut passer en mode démon.

● Terminaison du programme quand tous les threads non démons sont terminés.

● C'est la JVM qui contient tous les threads. Le garbage collector est lui même un thread de basse priorité accompagnant toutes les exécutions de programme Java, chargé de rendre au système toutes les zones mémoires qui ne sont plus référencées par le programme. On peut appeler explicitement le GC pour libérer la mémoire lorsqu'on « désalloue » par exemple un gros tableau : System.gc().

États d'un thread Java

Newborn

Blocked

Runnable

Dead

Running yield()

start()

sleep() wait() E/S

notify() E/S terminée

29



● Soit en implémentant la l'interface Runnable.class Compte implements Runnable { int valeur; Compte(int val) { valeur = val; }

public void run(){ for (int i = 0 ; i<valeur ; i++) { System.out.print(valeur + " "); } }

public static void main(String[] args) { Runnable compte1 = new Compte(1); Runnable compte2 = new Compte(2000); new Thread(compte1).start(); new Thread(compte2).start(); }}

Gestion des threads en Java

30



● Soit en dérivant la classe Thread et en surchargeant la méthode run().class Compte extends Thread { int valeur; Compte(int val) { super(); valeur = val; }

public void run() { for (int i = 0 ; i<valeur ; i++) { System.out.print(valeur + " "); } }

public static void main(String[] args) { new Compte(1).start(); new Compte(2000).start(); }}


31



● On peut changer la priorité d'un thread : setPriority(int p)● On peut le déclarer comme étant démon : setDaemon(boolean on)● Suspendre un thread : wait()● Il sera remis en activité par notify() ou notifyAll()● Endormir un thread pour un temps donné : sleep(tps_milli)● Attendre la terminaison d'un thread : join()● Gérer les sections critiques avec synchronized.● L'odonnancement est soit, fait par l'ordonnanceur du système d'exploitation

(cas de Window's), soit, l'ordonnancement est fait par la JVM : green Thread. Dans ce dernier cas le SE ne s'occupe que de l'ordonnancement des applications ; c'est souvent le cas des UNIX.


32



Gestion des threads dans window's

HANDLE _beginthread(void *fonction_run, int taille_pile, void *liste_arg) ;

fonction_run est le pointeur de la fonction qui sera exécutée par le thread ;taille_pile est la taille de la pile en octet (la valeur 0 fixera celle-ci à une valeur par défaut définie au niveau de l’OS ;liste_arg est un pointeur vers des données à passer en paramètre de la fonction fonction_run.

La modification de la priorité d’un Thread se fait avec :SetThreadPriority( HANDLE h, int priorité ) priorité peut prendre différentes valeurs de 0 à 31 dont entre autres :●THREAD_PRIORITY_NORMAL : Indicates normal priority for the priority class. ●THREAD_PRIORITY_TIME_CRITICAL : Indicates a base priority level of 15 for IDLE_PRIORITY_CLASS, NORMAL_PRIORITY_CLASS, or HIGH_PRIORITY_CLASS processes, and a base priority level of 31 for REALTIME_PRIORITY_CLASS processes.

33



Gestion des threads dans les systèmes POSIX

Création :int pthread_create(pthread_t * thread, pthread_attr_t *attr, void * (*start_routine)(void *), void * arg);Prototype de la fonction exécutée par le thread à écrire par le programmeur : void* runDuthread (void *param) ;Si la fonction main se termine, le programme et tous les threads lancés se terminent aussi !

Il faut attendre les threads : (void) pthread_join (th1, (void *)&ret) ;

Le paramètre ret contiendra la valeur retournée par la fonction pthread_exit (int val) à exécuter avant de terminer un thread.

34



Gestion des threads dans les systèmes POSIX

Exemple :void *runDuThread (void *p) { printf ("je suis le thread n° %s\n", (char *)p ); pthread_exit(0);} main () { pthread_t th1 ; int ret ; pthread_create (&th1, NULL, runDuThread, "1") ; if (th1 == NULL) { perror ("Pb creation du thread\n") ; exit(0) ; } pthread_join(th1, &ret);}

35



La synchronisation des processus

Le partage d'une ressource (fichier, variable commune...) entre plusieurs processus peut s'avérer critique.

Supposons 2 threads voulant incrémenter chacun une variable globale cpt.En C : cpt++ ;En assembleur : mov %EAX, cpt

inc %EAXmov cpt, %EAX

supposons que cpt=10. Que se passe-t-il si le thread 1 est interrompu par le scheduler juste avant inc %EAX ET que le thread 2 qui incrémente, par la suite, jusqu'à 20 la variable cpt .=> lors de la reprise du thread 1, l'instruction mov cpt, %EAX mettra 11 dans cpt alors que le programmeur aurait aimé y trouver 21 !

36



La synchronisation des processus

L'incrémentation de cpt est donc critique. Il aurait fallu baliser cette partie de code pour éviter qu'un thread accède à cpt si un autre thread est bloqué dans une partie critique concernant cpt.

Les OS proposent plusieurs moyens pour baliser du code critique. En voici quelques-uns pour Windows :– Critical Section : uniquement entre thread (léger en mémoire) ;– Mutex : entre processus ou entre thread ;– Sémaphore : entre processus ou entre thread (permet le comptage automatique

du nombre d'accès).

Pour Unix on peut citer :– pthread_mutex pour les threads POSIX ;– Les sémaphores pour les processus ou les threads.

37



La synchronisation des processusEx : les sémaphores (Dijkstra, 1965)

Résolution du problème par balisage avec une variable "globale partagée"while (sema == 0) ;sema --;Code_critique() ;sema ++ ;

2 problèmes : 1, mineur : attente passive par consommation CPU !2, majeur : sema ++ : même situation que précédemment !

Une autre solution partielle : désactiver les interruptions avant le code critique et les réactiver après => ET SI LE CODE CRITIQUE PLANTE ???!!!!

38



La synchronisation des processusEx : les sémaphores (Dijkstra, 1965)

- Variable système (entier) accessible par tous les processus autorisés.- Accès uniquement par 3 fonctions : Init( ), P( ) et V( ).- Les fonctions ne sont pas "preemptables" : opérations atomiques- P( ) : si le sémaphore est >0, le décrémenter sinon bloquer le processus.

=> évite de consommer de la ressource CPU !- V( ) : incrementer le sémaphore.- Init ( ) : donner une valeur au sémaphore.

En gras, figure les 3 qualités d'un système de balisage, sémaphores ou autres !

39



La synchronisation des processusEx : les sémaphores

Problème des philososphes

Un philisophe : 3 états- pense (pdt un temps aléatoire)

- a faim (essaye de prendre 2 fourchettes)

- mange (pdt un tps aléatoire)

40


ch 1 – Le multi-tâcheLe problème des philosophes :

On veut éviter 2 problèmes qui illustrent des situations de concurrence sur le partage de ressources entre processus.

L'interblocage : chaque philosophe a pris une fourchette et attend que la 2ième soit libérée.

La famine : un philosophe ne pouvant pas manger repose sa fourchette et attend. Un cas critique ayant une faible chance de se produire est celui ou les philosophes attendent le même temps à chaque fois...

Résolution (1) par un sémaphore : avant de prendre les 2 fourchettes, manger puis rendre les fourchettes, un philosophe prend un sémaphore et le rend à la fin des 5 opérations. Pb : un seul philosophe mange à la fois.Résolution (2) par 6 sémaphores (un de test et un par philosophe) : chaque philosophe qui a faim prend le sémaphore de test et vérifie qu'il peut manger. S'il ne peut pas, il libère le sémaphore de test et bloque sur son sémaphore. Quand un philosophe a fini de manger, il test si ses voisins peuvent manger et libère leur sémaphore dans ce cas.

41



Les blocs synchronisés Java

On peut baliser des méthodes ou des parties de code critique par le mot clé synchronized

Dans ce cas la JVM posera un verrou sur l'objet auquel appartient le code.

Soit un thread qui est en train d'exécuter du code «synchronisé» d'un objet.Soit un autre thread voulant exécuter du code «synchronisé» (même différent) du même objetalors, ce deuxième thread sera préempté et retournera dans l'état runnable.

Si un thread est dans l'état « bloqué » dans du code «synchronisé» (appel à wait()), il n'empêche pas l'exécution du code par un autre thread.

Lors de l'appel à notify() dans du code associé à l'objet synchronisé, un thread bloqué sur cette objet sera réveillé (pris au hasard). NotifyAll réveille tous les threads bloqués.

Exemple le tampon : 2 accesseurs (put et get) pour mettre ou retirer une chaîne de caractères. Si la place est déjà prise en bloque le thread.

42



Les bloc synchronisés Java

class Tampon { private String data; public synchronized void put(String put_data) { while (data != null) { // tampon non vide donc on attend try { wait(); } catch (InterruptedException e) {} } data = put_data; notifyAll(); // Les autres peuvent se réveiller return; } public synchronized String get() { while (data == null) { try { wait();} catch (InterruptedException e) { } } String get_data = data ; data = null ; notifyAll(); return get_data; }}

43



Les Tubes

L'interprète de commande permet d'exécuter 2 commandes en même temps dont la sortie standard de l'une sera reliée à l'entrée standard de l'autre par le signe pipe : "|". La commande suivante affichera les processus dont le nom contient le mot "bash" ps -e | grep "bash"

Les tubes sont de 2 types : anonymes ou nommés

FIFO de taille limitée (typiquement 2 kO).

Ils sont souvent unidirectionnels, sequentiels, bloquant ou pas lors d'une lecture d'un tube vide (flag O_NONBLOCK) : permet la synchronisation.

ps -e grep "bash"

44



Lancement d'une commande existante avec redirection des E/SL'appelant écrit comme dans un fichier et ceci est passé via un tube au programme appelé. Celui-ci récupère les informations sur stdin ou les envoie sur stdout FILE *popen (const char *commande, const char *type);int pclose (FILE *stream);

Les Tubes anonymes Unix

Il faut un lien de parenté entre les processus ;Ouverture avec la fonction pipe (int *);Le descripteur est un tableau d'entier : int p[2]p[0] permet de lire le tube, p[1] d'y écrire

Utilisation des fonctions d'ES classiques : read, write, close, fcntl

dup2( int t, int es) permet d'affecter le tube t à l'entrée/sortie es. Pour stdin es=0, stdout es = 1 et stderr es=2.

45



Les Tubes nommés Unix (ou VxWorks)Pas besoin de lien de parenté.

Orientés caractère (UNIX, Windows) ou message (VxWorks)

Il faut créer le tube au niveau du système de fichiers : mkfifo MonTubeutilisation de pipeDevCreate() avec VxWorks

Ouverture comme un fichier avec la fonction int open (char *, int mode)utilisation de pipeDrv() avec VxWorks

Utilisation des fonctions d'ES classiques :int read ( int desc, char * buf, int lg_buf) ;int write ( int desc, char * buf, int lg_buf) ;int close (int desc) ;int fcntl (int desc, int cmd) ;

46



Exemple : le père écrit et le fils traduit en majuscules.#define MAXCAR 100main () { int tube12[2], tube21[2], pid, i ,t ; char buf[MAXCAR] ; pipe (tube12) ; pipe (tube21) ; pid = fork() ; if (pid == 0) { for(;;) { t=read ( tube12[0], buf, MAXCAR) ; if (t <= 0) { perror("read "); exit (0); } for(i = 0; i < t; i++) if (buf[i] >='a' && buf[i] <='z') buf[i] = buf[i]-32 ; t=write ( tube21[1], buf, t) ; } } else { do { printf ("phrase : \n") ; scanf ("%s",buf); t=write( tube12[1], buf, strlen(buf)) ; t=read ( tube21[0], buf, MAXCAR) ; printf ("\ttraduction : %s \n", buf); } while (strncmp ("QUIT", buf, 4) ) ; kill (pid, SIGKILL); close(tube12[1]) ; close(tube12[0]) ; close(tube21[0]) ; close(tube21[1]) ; wait (&i); }}

47



Communications inter processus – autres concepts:

Nous avons déjà vu les tubes. Il existe aussi, entre autres :La mémoire partagée : Une zone de mémoire est partagée par plusieurs processus. Elle est vue comme un tableau. Il n'y a pas de mécanisme de synchronisation. Fonction Linux associée: shmget(...).Les fichiers mappés en mémoire : C'est une zone de la mémoire partagée par plusieurs processus. Elle est vue comme un fichier. Il n'y a pas de mécanisme de synchronisation. Fonction windows associée: CreateFileMapping(..)Les sockets : Permet d'envoyer des informations à travers un réseau. Traité dans le chapitre sur les réseaux.Les RPC (Remote Procedure Call) : Permet à un processus d'appeler une fonction sur une autre machine. L'interface permet de masquer les différences entre machines telles que la taille des entiers...DCOM : Distributed Component Object Model. Permet à l'intérieur des environnements Windows de manipuler les données des objets à travers un réseau en faisant des appels aux méthodes des objets à distance.

48


Ch 2 – La gestion de la mémoire


ch 2 – La mémoire

Plan

● Le matériel● La multi programmation● Le concept de mémoire virtuel● Les algorithmes de remplacement de pages

49



Le matériel (données AMD Athlon 64):

- Les registres du processeurs – (tps d'accès moyen à un mot 64 bits : 0,3 ns)- Cache de niveau 1 : à l'intérieur du processeur - 64 ko (1 ns)- Cache de niveau 2 : à l'intérieur – SRAM de de 512 ko- Cache de niveau 3 : à l'extérieur – SRAM de de 2Mo- Mémoire principale : SDRAM – jusqu'à 4Go (de 5 ns à 100 ns))- Disque dur : qq 100 Go (de 1us à 1ms)

50



La mono programmation :

=> découper les programmes et ne charger en mémoire que ce qui est utile.

Rem : le noyau sur certains systèmes embarqués peut être situé en ROM, et "remappé" en RAM. Cette technique a tendance à disparaître car la ROM (Flash ou EEPROM) est trop lente et on préfère charger l'intégralité de la ROM en RAM.

51



autres problèmes :

● Si un processus fait une demande d'allocation dynamique de mémoire ? ● Que veut dire mov %EAX, 0x200 pour les processus 1 et 2 ? est-ce la même

case mémoire ?● Comment protéger les processus entre eux ?● Le compilateur ne sait pas où va être chargé le programme. Donc :

– Soit le programme possède une table de toutes les adresses qui doivent être modifiées par le chargeur de programme (lourd...) ;

– Soit le processeur possède un registre de base qui permet de modifier l'adresse : pour le Intel 8086, CS permet de modifier le registre d'instruction IP en ajoutant 16*CS à IP pour avoir la valeur exacte de l'adresse physique du code.

● L'allocation dynamique (malloc, free) génère de la fragmentation dans la mémoire virtuelle au cours du fonctionnement d'un programme !

● Lorsque la pile s'accroît jusqu'à atteindre le sommet de la mémoire, comment continuer le programme sans faire planter le système ?

52



Les différents types de découpages :

Le va-et-vient : Tout le programme et ses données sont chargés en mémoire. Le code et les données sont remis sur le disque quand on exécute un autre processus.

La mémoire virtuelle (utilisé dans les processeurs modernes): - Le code, les données et la pile d'un processus sont séparés dans des segments

différents (protection des segments entre eux);- les segments sont découpés en tranches;- la mémoire physique est elle aussi découpée en tranches de même taille ;- le programme "voit" un adressage plan virtuel, toujours le même.- les adresses virtuelles sont traduites en adresses physiques par le Memory

Management Unit (unité spécialisée du processeur) ;- le CPU connaît par la table des segments l'adresse de début et de fin de chacun des

segments pour chaque processus ainsi que le privilège associé (mode noyau ou utilisateur) ;

53



La segmentation de la mémoire virtuelle :

- Certaines pages ont été déchargées sur le disque (parce que la mémoire physique est trop petite) ;

- D'autres sont en mémoire physique ;- Et certains espaces sont laissés vides (réservé à l'allocation dynamique...)

54



La mémoire virtuelle

Avantage de la segmentation :– Permet la protection des processus : certaines adresses ne référencent aucun

segment valide. Le CPU peut donc détecter une telle référence et arrêter le processus qui est en train de planter. L'adresse 0x00000000 n'est jamais attribuée ; ce qui permet de détecter une référence à un pointeur NULL de la part d'un programmeur indélicat !!

– Aussi certains segments comme le code sont déclarés en lecture seul. Là encore le CPU peut détecter une tentative d'écriture dans un tel segment.

– Partage du code : si plusieurs processus se partagent le même code, la segmentation permet de n'avoir en mémoire physique qu'une seule fois le code, mais référencé plusieurs fois.

55



La pagination (swap)

La table des pages :

56



Les algorithmes de remplacement de pages

Quand la mémoire est pleine, quelle page retirer pour mettre la nouvelle ?– FIFO : La table des pages est gérée par une liste chaînée. C'est la page la plus ancienne qui est

retirée.– LRU (least recently used) : On retire la page dont la date de la dernière utilisation est la plus

lointaine.LRU est l'un des meilleurs algorithmes mais il demande beaucoup de ressources matérielles (gestion

efficace de la date...) : il existe des approximations de cet algorithme.FIFO souffre du problème de l'anomalie de Belady :supposons une suite d'accès à ces pages :

1 2 3 4 1 2 5 1 2 3 4 5Regardons maintenant le nombre de fautes de pages générées (pages absentes de la

mémoire physique) en fonction du nombre de pages de la mémoire physique :nombres de pages : 1 2 3 4 5 6 7nombres de fautes : 12 12 9 10 5 5 5 Le nombre de fautes pour une mémoire dont la taille est de 4 pages est supérieur à celui pour

une taille de 3 pages.

57



Exemple, le pentium

● Dispose de 16 k segments indépendants ayant une capacité allant jusqu’à 1 milliard de mots de 32 bits (4 Go).

● La mémoire virtuelle est fondée sur deux tables :– La table locale de descripteurs, (LDT), propre à chaque programme. Elle contient ses

segments avec notamment les segments de code, de pile et de données;

– La table globale de descripteurs, (GDT), unique pour tout le système et partagée par tous les processus. Elle contient les segments du système et notamment ceux du noyau.

● Le 386 dispose de six registres de segments. Pour accéder à un segment particulier, par exemple le segment de code d’un processus, il charge un sélecteur dans le registre CS. Ce sélecteur correspond à un indice dans l’une des deux tables. Chaque entrée de ces 2 tables contient l’adresse de base du segment, l’adresse de limite ainsi que certains autres champs dont le bit de présence/absence en mémoire physique.

58



Exemple, la segmentation dans le pentium

Grâce à l’adresse de base, le microprocesseur peut convertir les décalages générés en adresses linéaires de 32 bits.

Adresse linéaire = déplacement (programme) + adresse de baseadresse de base = f ( sélecteur)

sélecteur = 13 bits index de segment (8k descripteurs) 1 bit : présence GDT/LDT 2 bits : privilège : (noyau, appel système, DLL, programme utilisateur)

Enfin : L'adresse linéaire est virtuelle => mappage en adresse physique.

Adresse virtuelle = 10 bits pour le répertoire ; 10 bits pour la page ; 12 bits pour le déplacement.

59



Exemple, la pagination du pentium

D i r

1 0 2 4 e n t r é e s

P a g e O f f s e tM o t s é l é c t i o n n é

P a g e r é e l l eR é p e r t o i r e d e s p a g e s ( P a g e d i r e c t o r y ) T a b l e d e s p a g e s

60


Ch 3 – La gestion des entrées / sorties


ch 3 – Les entrées - sorties

Plan

● Le matériel● Les différents types d'E/S● Le logiciel : les pilotes● Exemple : pilote monocouche● Exemple : pilote multicouche● Exemple : chargement d'une DLL d'un pilote.

61



Le matériel – exemple l'architecture d'un PC des années 90.

RAM

62



Le matériel

l'architecture d'un PC moderne.

63



Classification des E/S

Lentes : interfaces avec l'homme (ex : clavier), des périphériques lents (ex : disquette) ou attente d'un évènement ( ex : trame venant du réseau). Accès asynchrone (une IT est envoyée pour dire que l'opération est terminée)

Rapides : interfaces avec des périphériques rapides (ex : disque dur). Accès synchrone (l'appel système "retourne" quand l'opération est terminée).

=> L'ordonnanceur ne devra pas avoir le même comportement lors d'une attente de la fin d'une opération sur une E/S rapide ou sur une E/S lente.– On pourrait croire que, même rapides, les disques durs sont incomparablement plus

lents que les CPU et donc que le CPU a tout intérêt à passer à autre chose dès qu'il attend un disque dur. Il n'en n'est rien ! Les disques durs utilisent une mémoire cache où l'information demandée a toutes les chances d'y être déjà.

– De plus, A cause des pipelines très profonds des processeurs modernes et du nombre croissant des informations à sauvegarder lors de la commutation de contexte, le temps de commutation est de l'ordre de la microseconde (1000 cycles d'horloge à 1GHz !!) soit comparable au temps d'accès à la mémoire cache du disque !!

64



Adressage

Accès au registre de configuration ou de dialogue avec le matériel :

– Instructions particulières du CPU : IN et OUT. Dans ce cas les adresses positionnées sur le bus d'adresse sont envoyées par le chipset aux périphériques et non à la mémoire grâce à un fil particulier du CPU sur le bus.

– E/S mappées en mémoire. Dans l'espace d'adressage d'un processus se côtoient des adresses RAM et des adresses d'E/S. Le chipset est configuré au démarrage soit par le Bios, soit par un dialogue Plug & Play, pour reconnaître les adresses dédiées aux périphériques.

Techniques de programmation :– Polling : peu efficace car attente passive– Interruption : peu efficace car "context switching" couteux– DMA : nécessite un contrôleur de DMA gérant ainsi plusieurs périphériques : un par

canal.

65



Les E/S "bufferisées"

● Utile en lecture et écriture.● Un tampon est inséré dans l'espace noyau pour améliorer l'accès aux E/S, lorsque celui-ci

se fait octet par octet. Le tampon est écrit d'un seul bloc lorsque :– L'utilisateur le demande : flush() ;– Un caractère spécial à été détecté : '\n' par exemple ; – Le tampon à atteint une taille limite.

● Tampon dans l'espace noyau car évite qu'il soit "swappé" sur le disque en même temps que le processus utilisateur. Permet de recevoir des octets même si le processus est dans l'état bloqué.

● Double tampon : permet de recevoir des octets même pendant une copie du premier tampon vers l'espace utilisateur.

● Géré par l'OS : permet à plusieurs processus d'utiliser en même temps l'E/S. Attention à la réentrance !

● Alternative : Spooling : un processus à part s'occupe de l'E/S. Exemple, imprimante.

66



Le logiciel

Pilotes

1 ) API utilisateur (dependant de la classe de périphérique : ex stockage)POSIX : open(), read(), write(), ioctl(), close()Win32 : CreateFile, ReadFile(), WriteFile(), WaitForSingleObject(), CloseHandle().

Que ce soit un disque dur ou une clé USB, les fonctions de manipulation sont les mêmes.

2 ) API propre au système (dépendant du périphérique). Les concepteurs des systèmes d'exploitation décrivent l'interface et les services que doit rendre un type de périphérique. Le logiciel appelé pilote est fournit par le fabricant du périphérique.

67



Exemple de pilote monocouche dans windows XP- Réponse à une demande d'interruption matériel -

1. Le périphérique génère une IT qui est capturée par l'OS.2. L'OS appelle l'ISR (interrupt service routine) du pilote.3. Ce dernier désactive la demande d'interruption 4. Le pilote effectue une demande d'interruption logicielle (DPC, diferred procedure call)

de priorité moyenne.5. Lorsque le niveau des priorités des interruption traitées par l'OS à rejoint celui de la

DPC, l'OS exécute la DPC. Le pilote finit le travail de traitement de l'interruption.

Ce système de réponse en 2 parties à l'avantage de répondre rapidement au périphérique tout en laissant le processeur disponible pour toute demande prioritaire.

68



Un exemple d'E/S multicouche : l'accès au réseau.

● Côté matériel, plusieurs protocoles : ethernet, WIFI, modem● Côté utilisateur, plusieurs protocoles aussi : IP, NETBIOS● Au milieu, plusieurs services : fiables, temps réel...

Le modèle OSI :7 – Application (mail, web, FTP, partage de ressources...)6 – Présentation (codage des données, format...)5 – Session (login, mot de passe)4 – Transport (contrôle d'erreurs, connexion/déconnexion, aiguillage vers la bonne

application)3 – Réseau (adressage, routage)2 – Liaison (accès et partage de la liaison, contrôle d'erreurs, connexion/déconnexion,

adressage, limite d'une trame...)1 – Physique (représentation d'un bit, connectique...)

69



Un exemple de chargement de DLL pour piloter le bus USB.Le code de l'exemple montre juste comment récupérer le pointeur de fonction dans la DLL puis appeler la fonction.typedef void (*UseHidCreateObject) (useHid** ); // prototype de la fonction à charger HINSTANCE dll ;useHid* hidObject;UseHidCreateObject useHidCreateObject ; //pointeur de la fonction chargée

main() {// Chargement de la DLL en mémoire

if ((dll=LoadLibrary ("c:\\windows\\system\\useHid")) == NULL ) {printf ("pb chgt dll \n") ;exit (0) ;

}// Recuperation des pointeurs de fonctions dans la DLL

useHidCreateObject = (UseHidCreateObject)GetProcAddress(dll,"useHidCreateObject");

if (useHidCreateObject == NULL) {printf ("pb chgt fn Create \n"); exit (0) ;

}// appel de la fonction qui initialise le piloteuseHidCreateObject(&hidObject);

70


ch 4 – Le système de fichier

Ch 4 - Le système de fichier

● Le matériel● Organisation● Le système FAT-32

71



● Structure d'un disque dur

72



● Organisation

● Secteur : 512 octets● Taille du disque : nb_cylindres x nb_têtes x nb_secteurs_par_piste● Cylindre = toutes les pistes alignées de tous les plateaux

Exemple : C/H/S = 65536/16/255Taille = 127,5 Go (qui est d'ailleurs la taille limite de l'adressage IDE)

cylindre (virtuel)

plateau

secteur

piste

tête

73



Organisation du disque

● Unité de base : le cluster : ensemble de secteurs.● Exemple, en FAT32, taille d'un cluster pour des disques < 1To : 4 ko

Partition d'un disque exemple :

Lorsque la machine boot, elle exécute le programme du BIOS qui cherche un périphérique bootable. Lorsqu'il est trouvé, le BIOS exécute le programme (loader) du secteur 0 (MBR). Le chargeur du système d'exploitation charge alors le système qui se trouve sur la bonne partition.

Le MBR contient aussi les informations de découpage en partition (C:, D:,....)

0 Partition 2Partition 1 Partition 3

secteur 0 : Master Boot Record (MBR)

74



Organisation de la FAT-32

● Partition :

● Le boot sector décrit la partition : nom du volume, nombre d'octets par secteurs, nb de secteurs par clusters...

● Le répertoire racine, comme les autres répertoires, contient des entrées ( sur 32 octets)

pour chacun des fichiers ou répertoire qu'il contient. Les informations sont : le nom du fichier/répertoire, sa taille (sur 4 octets, donc max = 4Go) , la date de création, le numéro du premier cluster où trouver le répertoire...

● Dans chaque bloc (cluster), les 4 derniers octets servent à numéroter le bloc suivant.

Boot sector

FAT répertoire racine Bloc 1 Bloc 2 ...

75



Organisation de la FAT-32 (suite)

● La table d'allocation des fichiers (FAT):Permet de repérer rapidement les blocs libres.Permet d'accéder rapidement à des données lors d'un accès aléatoire.

Chaque bloc du disque est repéré par une entrée sur 4 octets indiquant si le bloc est défectueux (0), libre (1) ou indiquant le bloc auquel il est chaîné. La valeur ffffffff est donnée pour le dernier bloc d'un fichier. Exemple :

No bloc : 4 5 6 7 8 9 10 11valeur : 1 1 7 9 0 11 1 ffffffff

Ce fichier commence au bloc 6 et se termine au bloc 11 et contient 4 blocs.

● Lors d'un arrêt brutal de la machine il se peut que la FAT et le système de fichiers soient incohérents. Il faut dont parcourir tous les blocs du disque et reconstruire la FAT.

76



Les inconvénients de la FAT 32

● Nombre de clusters limités : adressage des clusters sur 28 bits. La taille d'un cluster dépend de la capacité du disque. Pour gérer les gros disques : clusters de grandes tailles : 32 Ko

● Donc capacité maximum d'un disque : 2^28*32 = 8 To

● Donc taille minimal d'un fichier : 32 Ko => beaucoup de places perdues

● De plus, beaucoup de fragmentation

● Taille maximum d'un fichier : 4 Go... ce n'est même pas l'image ISO d'un DVD...

● Donc mieux vaut utiliser des systèmes de fichiers récents : NTFS, ext3fs...

77



Types d'accès

● Accès séquentiel. Les données sont de tailles variables et séparées par un séparateur, comme les mots par des espaces dans un texte. L'accès ne peut se faire qu'à partir du début en suivant chaque séparateur pour arriver à la donnée voulue.Ce type d'accès est celui que l'on trouve aussi sur les périphériques à bande. C'est aussi comme cela que l'on qualifie l'accès aux fichiers textes.

● Accès aléatoire. Les données sont de taille fixe. Pour accéder à l'enregistrement N, il suffit de se déplacer de N x taille d'un enregistrement.Cohérents. C'est aussi comme cela que l'on qualifie l'accès aux fichiers binaires.

systèmes d'exploitation - bde ensicaenlefebvre/cours/cours_ser.pdf · années 60, premiers os...

Documents