PROGRAMMATION

SYSTÈME ET RÉSEAUX
Pr. M.A. EL KIRAM.
Univérsité Cadi Ayyad.
Faculté des Sciences Semlalia.
Département d’Informatique.
kiram@uca.ac.ma
Plan
 Eléments de bases des processus.
 Processus
 Etats de processus.
 Représentation interne de processus.

 Opérations sur les processus.

 Création de processus avec fork()
 Synchronisation de processus.
 Appels systèmes wait(), waitpid(), exit().

 Famille des appels systèmes exec.

 Execl(), execv(), execlp(), execvp().
Plan (suite)

 Les threads
 Introduction, caractéristiques et avantages
 Gestion des threads sous Linux.
 Création des threads.
 Suspension des threads.
 Terminaison des threads.

 Communication interprocessus.
 Variables et fichiers communs.
 Les signaux.
 Les messages.
 Tubes.
 Sockets.
Plan (suite)

 Conception des systèmes parallèles.

 Notions de taches.
 Systèmes de taches et graphes de précédence.
 Parallélisme dans un système de taches.
 Synchronisation de processus.
 Problème de la section critique.
 Algorithme d’alternance.
 Algorithme de verrouillage.
 Algorithme de Peterson.
 Instruction test&set.
 Les sémaphores.
Plan (suite)

 Programmation des interfaces réseaux (sockets)

 Adressage
 Socket en mode connecté (STREAM).
 Socket en mode non connecté (DGRAM).
 Socket en mode local (AF_UNIX).
 Socket en mode INTERNET (AF_INET).
Eléments de bases des processus

La notion qui éclaire le fonction des systèmes multiprogrammés est celle

des processus.
Processus

Notion de processus:

 Terme introduit dans les années 60 par MULTICS.

 Abstraction de l’activité du processeur.
Processus

- Un programme qui s’exécute.

- Possède un compteur ordinal.
- des registres.
- des variables.
- Une pile d’exécution.
Processus

Segments de données
Un processus est composé d’un
espace de travail formé de 4
segments. Segments de données supp

Segment de code

Segment de pile
Processus

Segment de code correspond aux Segments de données

instructions, en langage machine
du programme à exécuter. Segments de données supp

Segment de code

Segment de pile
Processus

Le segment de données et Segments de données

segment de données
supplémentaire contiennent les Segments de données supp
variables du programme.
Segment de code

Segment de pile
Processus

Les appels systèmes, les Segments de données

fonctions, avec leurs paramètres
s’empilent dans la pile. Segments de données supp

Segment de code

Segment de pile
Processus

Conceptuellement, chaque processus possède son propre processeur

virtuel.

En réalité le vrai processeur commute entre plusieurs processus.

Représentation interne de processus

Un processus est représenté par une structure interne appelé Bloc de Contrôle de
Processus PCB (Process Control Bloc).

La PCB contient l’ensemble des informations qu’il faut sauvegarder pour

permettre la reprise ultérieure de l’exécution du processus, lorsque celle-ci est
interrompu.
PCB
Pid du processus
ppid
Etat du processus
Compteur ordinal
Valeurs de registres
Quantité de mémoire allouée
Temps CPU
….
Processus.

Programme A Programme B

Interruption Sauvegarde PCB(A)

Charger PCB(B) Exécution

Sauvegarde PCB(B) Interruption

Execution Charger PCB(A)

Etats de processus

L’état d’un processus permet d’exprimer si le processus est:

 Réellement exécuter.
 Prêt à être exécuter.
 En attente de ressources autre que le processeur
Etats de processus
Nous distinguons alors les états suivants:
 En exécution.
 Prêt.
 En attente.

On distingue en plus:
 Bloquer : processus en attente d’un événement qui se produira jamais
 Suspendu : processus mis temporairement en retrait.

C’est l’OS qui détermine et modifie l’état d’un processus sous l’effet
d’événements.
Etats de processus
Les événements peuvent être:

 Internes au processus:
Une demande d’E/S peut faire passer de l’état « en exécution » à l’état « prêt ».

 Externes au processus:
Attribution de ressources fait passer de l’état « en attente » à l’état « prêt ».
Atelier N°1

Gestion de processus
Opérations sur les processus

L’ensemble minimum d’opérations sur les processus réalisées par l’OS :

 Créer et détruire.
 Mettre en attente et réveiller.
 Suspendre et reprendre.
 Modifié la priorité
Création de processus

Un processus peut créer un autre.

Le premier est appelé le processus père.
Le second, le processus fils.

Le fils peut à son tour créé d’autre processus dont il devient leur père
Création de processus
P1

P11 P12 P13

P111 P112 P121

P…
Création de processus sous Unix/Linux

L’appel système fork() est la seule véritable façon de créer des processus fils.

#include <sys/types.h>
#include <unistd.h>

pid_t fork(void)

Cet appel duplique le processus qui l’exécute en deux processus identiques au nom près,
qui s’exécutent en parallèle et retourne deux valeurs différentes aux processus père et
fils
Création de processus

La valeur de retour de fork() est :

 0 dans le processus fils.

 > 0 dans le processus père et

correspond au pid du fils.

 < 0 si la création a échouée

Création de processus

La valeur de retour de fork() est : Processus initial

Pid = 13

 0 dans le processus fils.

 > 0 dans le processus père et I = fork()

correspond au pid du fils.
Processus fils
Pid = 14
 < 0 si la création a échouée I=0
I = 14.
Pid = 13
Exemple
Exemple
#include<stdio.h>
#include <unistd.h> Else
#include <sys/types.h> {
Const char * quisuisje = NULL
printf(« je suis %s \n », quisuisje);
Int main()
}
{
Return 0;
pid_t pid;
quisuisje=« le père »; }

pid = fork();
If (pid == 0) {
quisuisje=« le fils »;
printf(« je suis %s \n», quisuisje);}
Q. Donnez le schéma d’exécution de:

#include<stdio.h>
#include <unistd.h> Else
#include <sys/types.h> {
Const char * quisuisje = NULL
printf(« je suis %s \n », quisuisje);
Int main()
}
{
Return 0;
pid_t pid;
quisuisje=« le père »; }

pid = fork();
If (pid == 0) {
quisuisje=« le fils »;
printf(« je suis %s \n», quisuisje);}
Atelier

Création de processus.
Atelier 1
Ecrire un programme prog1.c dans lequel le processus père crée un
processus fils.
Le père écrit « je suis le père ».
Le fils écrit « Je suis le fils ».
Atelier 2
Ecrire un programme prog1.c dans lequel le processus père crée un
processus fils.
Le père écrit « je suis le père ».
Le fils écrit « Je suis le fils ».

Montrez la valeur de retour de fork() dans le père et dans le fils.

Atelier 3
Ecrire un programme prog1.c dans lequel le processus père crée un
processus fils.
Le père écrit « je suis le père ».
Le fils écrit « Je suis le fils ».

Faire perdre du temps dans le père et dans le fils et voir la duplication de

prog1 dans la liste des processus.
Atelier 4
Ecrire un programme prog1.c dans lequel le processus père crée un
processus fils.
Le père écrit « je suis le père ».
Le fils écrit « Je suis le fils ».

Faire perdre du temps dans le père et dans le fils et voir la duplication de

prog1 dans la liste des processus.

Modifier ce programme de telle sorte que père et fils montrent leur pid.

Utiliser getpid().
Atelier 5
Ecrire un programme prog1.c dans lequel le processus père crée un
processus fils.
Le père écrit « je suis le père ».
Le fils écrit « Je suis le fils ».

Faire perdre du temps dans le père et dans le fils et voir la duplication de

prog1 dans la liste des processus.

Modifier ce programme de telle sorte que père et fils montrent leur pid et
le pid de leur père.

Utiliser getpid() et getppid().

Atelier 6
- Reprendre prog1.c
- Ajouter sleep(20) dans le fils et sleep(10) dans le père. Constatez.
- Ajouter sleep(10) dans le fils et sleep(20) dans le père. Constatez.
Atelier 7
Interpréter l’exécution du programme suivant et donner son schéma d’exécution.
 
$cat chaine.c
 
#include <sys/types.h>
#include <unistd.h>
 
int main(void)
{
int i, j, k,
n = 5;
pid_t fils_pid;
 
for (I = 1; i<n ; i++)
{
fils_pid = fork();
If (fils_pid > 0) //c’est le pere
break ;
printf ("Processus %d avec pere %d\n", getpid(), getppid()) ;
}
 
// pour faire perdre du temps au processus
for (j = 1 ; j < 100000 ; j++)
for (k = 1 ; k < 1000 ; k ++) ;
}
Atelier 8

Ecrire un programme tfotk.c dans lequel père et fils partagent une varialble a initilalisée à 10
Père ajoute 30 à a.
Fils ajoute 40 à a

Constatez
Atelier 9
Atelier 9
Montrer la différence entre les deux programmes

Fork1.c Fork2.c
# include <sys/types.h> # include <sys/types.h>
#include <unistd.h>
#include <unistd.h>
#include <stdio.h>
#include <stdio.h>  
Int main ()
Int main () {
{ int i, n=5;
pid_t pid;
int i, n=5;
 
int childpid; for (i=1; i<n; i++)
  {
for ( i=1; i<n; i++ ) If ((pid = fork())==-1)
{ Break;
If (pid ==0)
If ((childpid = fork()) <= 0) break;
Printf(" Processus %d avec pere %d, i=%d\n", getpid(),
printf(" Processus %d avec pere %d, i=%d\n", getppid(), i) ;
getpid(), getppid (), i) ; }
}
Return 0; Return 0 ;
} }
Détruire
Un processus peut se terminer de différentes façons:

- Se termine normalement.
- Exécute une instruction auto destructrice. (exit(), break…)
- Est détruit par un autre processus ( kill()).
Détruire
- Un processus détruit n’existe plus dans le système.
- Les ressources qui lui avaient été affectées sont libérées.
- son BCB est effacé.
Mettre en attente et réveiller

Lorsqu’un processus à besoin d’autre ressources autre que le processeur

pour poursuivre sa progression, il est mis dans l’état en attente.

Lorsque plus tard, le SE est en mesure de lui affecté les ressources

demandées, il réveille le processus pour le faire passer à l’état prêt
Suspendre et reprendre

La suspension est une opération qui amène un processus dans l’état

suspendu où sa progression est figée.

la suspension d’un processus provoque la sauvegarde de son BCP pour sa

reprise ultérieure.

Lorsque cette reprise intervient, le processus repasse à l’état prêt ou l’état

en attente