02/11/06Programmation multitâche sous Unix Isaip-Esaip 1
Groupe Isaip-Esaip
P. Trégouët – A. Schaal
remerciements à M. Benzaïd
pour sa contribution à la rédaction de ce document
Programmation multitâche Programmation multitâche sous unixsous unix
02/11/06Programmation multitâche sous Unix Isaip-Esaip 2
PLAN
Processus
Signaux
Tubes entre processus de filiation commune
Tubes nommés entre processus de filiation différente
File de messages
Segments de mémoire partagée
Sémaphores
Sockets
02/11/06Programmation multitâche sous Unix Isaip-Esaip 3
Livre de référenceLivre de référence
Programmation
système en C
sous Linux
Auteur : Christophe Blaess
Édition EYROLLES
02/11/06Programmation multitâche sous Unix Isaip-Esaip 4
ProcessusProcessus
Un processus est un programme en cours d’exécutionUn système multi-utilisateurs peut exécuter le même programme sous plusieurs processus, pour plusieurs utilisateursL'espace mémoire alloué à un processus est constitué :
du Code du programme en cours d’exécution (segment code ou segment text)des Données manipulées par le programme (segment data)du Descripteur du processus (informations relatives au processus, pile d’exécution,…)
pid_t getpid(void)
pid_t getppid(void)
uid_t getuid(void)
uid_t getuid(void)
pid_t PID : numéro de processus,
pid_t PPID: numéro de processus parent,
uid_t UID : numéro de l’utilisateur réel,
uid_t EUID:numéro de l’utilisateur effectif,
etc.
PrimitivesTypes d’informations : <unistd.h>
02/11/06Programmation multitâche sous Unix Isaip-Esaip 5
Manipulation des processus (1)Manipulation des processus (1)
Création ou duplication de processuspid_t fork(void) La valeur retournée est le pid du fils pour le processus père, ou 0 pour le processus fils. La valeur -1 est retournée en cas d'erreur.
Le fils hérite de presque tous les attributs du parent : segment code (partagé, copié), segment data (copié), PID/PPID (modifiées), signaux interceptés (conservés), descripteur de fichiers/tubes ouverts (copiés), pointeurs de fichiers (partagés)
Terminaison de processusvoid exit (int code_retour)
Attente de terminaison de processus enfantpid_t wait (int * code _retour),
pid_t waitpid (pid_t pid_enfant, int * code_retour, int options)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 6
Manipulation des processus (2)Manipulation des processus (2)
Sommeil de processusUnsigned int sleep (unsigned int nb_secondes)Un signal reçu interrompt le sommeil du processus. Le programme continue alors son exécution après l'appel de sleep(). La valeur retournée par sleep() est le nombre de secondes restantes
Recouvrement de processus = changement du programme exécuté par un processus (exec)
modification de l’image (le segment de code) du processus courantToutes les variables de l’ancien programme sont perduesIl n’est pas possible de revenir d’un exec. Les instructions qui suivent exec ne seront exécutés que si exec échouePassage de valeurs : par les variables d’environnement ou les paramètres du nouveau programmePrimitives correspondantes: exec{l|v}[e|p] man 3 exec
l : liste d’arguments : fournir la liste (char *arg0, char *arg1, …, 0) v : tableau d’arguments : fournir un pointeur sur le tableau (char ** argv avec
denier élément = ‘0’) Etc.
02/11/06Programmation multitâche sous Unix Isaip-Esaip 7
Deux processus peuvent éventuellement partager le même code (ceci est sous le contrôle du système) mais les espaces mémoires réservés aux variables sont complètement étanches : un processus n'a aucun accès aux variables d’un autre processus
On peut néanmoins créer une application multitâche et avoir besoin de synchroniser ces tâches ou d’échanger des informations entre ces tâches. Les systèmes d’exploitations sont donc munis de mécanismes appropriés
Synchronisation par signaux ou sémaphoresCommunication de données par fichiers, tubes (pipes) files de messages (queues ou boîtes à lettres) variables implantées dans un segment de mémoire partagée
Besoins de communication Besoins de communication entre processusentre processus
02/11/06Programmation multitâche sous Unix Isaip-Esaip 8
Communications Communications locales ou distanteslocales ou distantes
ProcessusUtilisateur
ProcessusUtilisateur
Noyau du S.E
Hôte
Communication intra-système
ProcessusUtilisateur
ProcessusUtilisateur
Noyau S.E
Hôte 2
Noyau S.E
Hôte 1
Communication inter-systèmes
Réseau
02/11/06Programmation multitâche sous Unix Isaip-Esaip 9
La communication par signaux La communication par signaux (1)(1)
Un signal peut être assimilé à une interruption logicielle (par analogie avec les interruptions matérielles)
Comme pour une interruption matérielle, la réception d'un signal interrompt le traitement en cours et exécute automatiquement la fonction associée au signal (programmation événementielle).
En langage C, l'association entre le numéro du signal et la fonction est réalisé par un appel à la fonction système signal().
Note : la fonction sigaction() peut être utilisée à la place de signal(). Voir man sigaction.
02/11/06Programmation multitâche sous Unix Isaip-Esaip 10
La communication par signaux La communication par signaux (2)(2)
Un signal est
Envoyé par un processus
Reçu par un autre processus (éventuellement le même)
Véhiculé par le noyau
Comment réagit un processus qui reçoit un signal ?Il interrompt le traitement en coursil exécute la fonction de traitement du signalil reprend l'exécution du traitement interrompu
Si le processus était endormi, il est réveillé par le signal. Après l'exécution de la fonction associée au signal, dans le cas où il est réveillé avant la fin d'une temporisation il ne se rendort pas; par contre s'il attendait la fin d'une entrée-sortie, il continue à attendre.
Comportement associée à la réception d'un signal :
En général un comportement par défaut est défini : Terminaison anormale du processus (ex: violation de mémoire, division par zéro)
Le processus peut ignorer le signal
Le processus peut redéfinir, par une fonction spécifique, son comportement à la réception d'un signal
02/11/06Programmation multitâche sous Unix Isaip-Esaip 11
Origine des signauxOrigine des signaux
Frappe de caractères
Erreurs du programme
Violation de mémoire, SIGSEGV
Division par zéro, SIGFPE
Commande killPrimitive système : kill(), alarm().
SIGINT
SIGQUIT
SIGSTP
CTRL-C
CTRL-\
CTRL-Z
signaltouche
02/11/06Programmation multitâche sous Unix Isaip-Esaip 12
Liste des signauxListe des signaux
demo@forum:~> kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL 5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE 9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR213) SIGPIPE 14) SIGALRM 15) SIGTERM 17) SIGCHLD18) SIGCONT 19) SIGSTOP 20) SIGTSTP 21) SIGTTIN22) SIGTTOU 23) SIGURG 24) SIGXCPU 25) SIGXFSZ26) SIGVTALRM 27) SIGPROF 28) SIGWINCH 29) SIGIO30) SIGPWR 31) SIGSYS 33) SIGRTMIN 34) SIGRTMIN+135) SIGRTMIN+2 36) SIGRTMIN+3 37) SIGRTMIN+4 38) SIGRTMIN+539) SIGRTMIN+6 40) SIGRTMIN+7 41) SIGRTMIN+8 42) SIGRTMIN+943) SIGRTMIN+10 44) SIGRTMIN+11 45) SIGRTMIN+12 46) SIGRTMIN+1347) SIGRTMIN+14 48) SIGRTMIN+15 49) SIGRTMAX-15 50) SIGRTMAX-1451) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-1055) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-659) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-263) SIGRTMAX-1 64) SIGRTMAX
02/11/06Programmation multitâche sous Unix Isaip-Esaip 13
Signaux les plus fréquemment utilisésSignaux les plus fréquemment utilisés
1 SIGHUP terminaison du processus leader 2 SIGINT frappe d’interruption (CTRL-C) 3 SIGQUIT frappe de quit (CTRL-\) 4 SIGILL instruction illégale 6 SIGABRT problème matériel 7 SIGBUS erreur sur le BUS 8 SIGFPE erreur arithmétique 9 SIGKILL signal de terminaison
la réaction à ce signal ne peut être redéfinie10 SIGUSR1 signal utilisateur11 SIGSEGV violation écriture mémoire12 SIGUSR2 signal utilisateur13 SIGPIPE écriture sur un tube non ouvert en lecture14 SIGALRM fin de temporisateur15 SIGTERMterminaison normale d’un processus17 SIGCHLD terminaison (arrêt) d’un fils18 SIGCONTcontinuation d’un processus arrêté par SIGSTOP19 SIGSTOP signal de suspension d’exécution de processus 20 SIGTSTP frappe du caractère de suspension sur le clavier (CTRL-Z)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 14
Envoi de signaux en langage CEnvoi de signaux en langage C
#include <signal.h>
int kill(pid_t pid,int sig)
pid : > 0 : pid de processus destinataire
sig : le signal à envoyer
Envoie un signal à un processus
#include <unistd.h>
unsigned alarm (unsigned nb)
Envoie un signal SIGALRM au processus en cours dans nb secondes.
Attention : ne pas mélanger l'utilisation de alarm et de sleep qui partagent le même "timer" (voir man alarm)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 15
Préparer la réception des signaux en Préparer la réception des signaux en langage Clangage C
#include <signal.h>
void (*signal(int signum, void (*handler)(int)))(int);
signum : le signal à intercepter
handler : pointeur sur une fonction qui gère le signal c'est simplement en C l'identificateur de cette fonction
ou constante correspondant à un comportement prédéfini:
SIG_DFL : comportement par défaut SIG_IGN : ignorer le signal
#include<unistd.h>
int pause(void);
Endort le processus appelant jusqu'à ce qu'il reçoive un signal.
on peut aussi utiliser sleep() si on veut limiter l’attente
02/11/06Programmation multitâche sous Unix Isaip-Esaip 16
Communication par signaux : exempleCommunication par signaux : exemple#include<signal.h>
void standard(int numero){ printf("standard Signal %d recu : \n",numero); }void message(int numero){ printf("message Signal %d recu\n",numero); }
main(){int numero; // traitements spécifiques for (numero=1;numero<32;numero++)signal(numero,standard); signal(SIGINT,message); signal(SIGQUIT,message); //traitements prédéfinis signal(1,SIG_DFL); signal(4,SIG_IGN);
// Rien à faire, sauf réagir aux signaux: attente passive while (1) pause();}
02/11/06Programmation multitâche sous Unix Isaip-Esaip 17
Un tube est traité comme un fichier ouvertIl est transmis aux processus enfants de la même manière que les fichiers ouvertsUn tube est cependant un fichier particulier :
Il n’a pas de nom dans l’arborescence des fichiers Il est connu par deux descripteurs (lecture, écriture)
On lit/écrit dans un tube comme on lit/écrit dans un fichier séquentiel
Utilisation des fonctions read et write (éventuellement fscanf, fprintf etc…)Les données ne sont pas structurées: le pipe ne contient qu’une suite d’octets
Un tube est comme un "tuyau" avec une entrée et une sortie :Plusieurs processus peuvent y écrire des donnéesPlusieurs processus peuvent y lire des données
Tubes : principe (1)Tubes : principe (1)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 18
Le fonctionnement est de type FIFO : On lit toujours les octets dans l'ordre où ils ont été déposés dans le tubeIl n’est pas possible de lire un octet sans voir lu tous ceux qui le précèdentUne donnée lue par un processus ne pourra jamais être relue par un autre processus
Les droits d’accès sont du même genre que les droits d’accès Unix sur les fichiers (rwx, rwx, rwx)Si un tube est vide, ou si tous les descripteurs susceptibles d’y écrire sont fermés, la primitive read() renvoie la valeur 0 (fin de fichier atteinte).Un processus qui écrit dans un tube qui n’a plus de lecteurs (tous les descripteurs susceptibles de lire sont fermés) reçoit le signal SIGPIPE
Tubes : principe (2)Tubes : principe (2)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 19
TUBES : primitives utilesTUBES : primitives utiles
Création : #include <unistd.h> int pipe(int p_desc[2])
p_desc[0] pour la lecture, p_desc[1] pour l’écriture
Entrées/Sorties :write (p_desc[1], buf_ecrire, nbre_octets)read (p_desc[0], buf_lire, nbre_octets)
FILE * fdopen():fprintf(), fscanf(),etc...fflush : écrire la zone tampon dans le tube avant qu’elle ne soit remplie
Pour éviter l’interblocage fermer le côté de tube non utilisé, par la primitive close()
02/11/06Programmation multitâche sous Unix Isaip-Esaip 20
TUBES : exempleTUBES : exemple
#include <signal.h>main(){int i, ret, p_desc[2];char c;pipe(p_desc); write(p_desc[1],"AB",2); close(p_desc[1]); for (i=1; i<=4; i++) {
ret = read(p_desc[0],&c,1) ;if (ret == 1) printf("valeur lue: %c\n",c) ;else perror("impossible de lire dans le tube\n") ;}
} Résultat de l’exécution :valeur lue : Avaleur lue: Bimpossible de lire dans le tube : Successimpossible de lire dans le tube: Illegal seek
02/11/06Programmation multitâche sous Unix Isaip-Esaip 21
TUBES NommésTUBES Nommés
Les tubes ordinaires, sont non visibles dans l’arborescence des
fichiers, et accessibles uniquement aux processus d’une même
affiliation
Tubes nommés : visibles dans l’arborescence de fichiers, utilisables entre processus ne partageant pas la même filiation
Par contre, aucune information n’est enregistrée sur disque, le transfert d’information s’effectue toujours en mémoire.
Primitives correspondantes :int mknod(const char *nom_fich,mode_t mode, dev_t dev)
int mkfifo (const char *pathname, mode_t mode);
Ouverture de tube par les processus connaissant le nom du tube :En lecture/écriture par open()
Par défaut, ouverture bloquante : lecteurs et écrivains s’attendent synchronisation
02/11/06Programmation multitâche sous Unix Isaip-Esaip 22
IPC = Inter Process CommunicationTrois types d’objets IPC :
files de message, segments de mémoire partagée sémaphores
En général ces objets sont créés par un processus et utilisés par d’autres, sans qu’il y ait de liens de parenté entre ces processus.A chaque objet IPC sera associée une clé d’identification de 8 chiffres hexadécimaux
Cette identification externe, définie au moment où on écrit le programme est analogue à un nom de fichier : on crée ou on cherche un sémaphore d’une valeur de clé donnée comme on ouvre un fichier de nom donnéCependant, on ne peut prévoir si un autre programmeur n’a pas par hasard utilisé la même clé pour un autre objet IPC dans une autre application multitâche. On pourra donc utiliser une fonction spéciale, ftok(), pour créer une clé unique à partir d’un nom de fichier existant dans le système de fichiers et d’un numéro de projet (ceci n'est donc définit qu’au moment de l’exécution, sur une machine donnée).
# include <sys/ipc.h>key_t ftok(const char *pathname,int proj_id);
Nommage des objets IPCNommage des objets IPC
02/11/06Programmation multitâche sous Unix Isaip-Esaip 23
Drapeaux :IPC_CREAT : créer un objet s'il n’existe pas
IPC_EXCL : échouer si l'objet existe déjà
IPC_NOWAIT : ne pas attendre
IPC_PRIVATE : clé privée, pas de lien avec le système de fichiers
Commandes :IPC_RMID : suppression
IPC_SET : mise à jour des attributs
IPC_STAT : lecture des attributs
Permissions : Analogues à celles du système de fichiers UNIX
Constantes communes relatives Constantes communes relatives aux primitives IPCaux primitives IPC
02/11/06Programmation multitâche sous Unix Isaip-Esaip 24
ipcs : liste des objets ipc existantsipcrm : suppression d’un objet ipc
mail:/home/demo # ipcs
------ Shared Memory Segments --------key shmid owner perms bytes nattch statu 0x00000001 720896 root 600 33554432 6 dest 0x00000012 753665 root 600 262144 1 dest 0x00000034 819202 root 600 33554432 11 dest
------ Semaphore Arrays --------key semid owner perms nsems0x00000005 98304 wwwrun 600 10x00000006 131073 wwwrun 600 1
------ Message Queues --------key msqid owner perms used-bytes messages0x00001f58 0 root 600 0 0
Commandes de manipulation des objets IPCCommandes de manipulation des objets IPC
02/11/06Programmation multitâche sous Unix Isaip-Esaip 25
Contrairement aux tubes une file de message contient des données structurées composées
D’un type de messageD’un message de longueur variable
A la différence des pipes, il sera possible d’attendre uniquement des messages d’un type donné: s’il n’y a que des messages d’un autre type, le processus sera bloqué (attente passive)
Comme les pipes, les files de message sont gérées selon un algorithme FIFO : on lit toujours le message du type cherché qui a séjourné le plus longtemps dans la fileL’attente est par défaut bloquante, mais, comme pour les pipes, et si cela est nécessaire, le processus peut ne pas attendre en positionnant le drapeau IPC_NOWAIT. Il recevra un code d’erreur lui indiquant s'il a ou non obtenu un message.Comme les pipes, les files de messages ont des droits d’accès de type Unix (rwx,rwx,rwx)
Files de messages : principeFiles de messages : principe
02/11/06Programmation multitâche sous Unix Isaip-Esaip 26
Files de messages : primitivesFiles de messages : primitives
Création : int msgget(key_t key, int flg) : retour = msq_id
Emission : (bloquante si file pleine et flg ne contient pas IPC_NOWAIT) int msgsnd(int msqid,struct msgbuf *msgp,int msgsz,int flg);
Avec struct msgbuf {long msgtyp; char * msgtext;}
Réception : (bloquante si file vide et flg ne contient pas IPC_NOWAIT) int msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);
msgtyp = 0 : premier message lumsgtyp > 0 : premier message de type msgtypmsgtyp < 0 : premier message avec un type ≤ |msgtyp|
Opérations de contrôle :
int msgctl(int f_id, int cmde, struct msqid_ds *structure)cmde = IPC_RMID, IPC_STAT, IPC_SETmsqid_ds : structure définie dans <sys/msg.h> qui donne des informations sur la file comme les droits d’accès, le dernier processus écrivain,etc.
02/11/06Programmation multitâche sous Unix Isaip-Esaip 27
Création d'une File de messages : exempleCréation d'une File de messages : exemple
#include <errno.h>#include <sys/types.h>#include <sys/ipc.h>#include <sys/msg.h>#define ID 123main(){int msqid ;
char *path = "nom_de_fichier_existant";
if (( msqid = msgget(ftok(path,ID),IPC_CREAT|IPC_EXCL|MSG_R|MSG_W))== -1)
{perror("Echec de msgget");exit(1);}
printf("identificateur de la file: %d\n",msqid);
printf("cette file est identifiée par la clé unique : %ld\n", ftok(path,ID)) ;
}
Résultat de l’exécution :identificateur de la file: 700cette file est identifiée par la clé
unique : 2064941749
02/11/06Programmation multitâche sous Unix Isaip-Esaip 28
Un segment de mémoire partagé est un espace de mémoire dans lequel un processus pourra "allouer" des variables accessibles par des pointeurs.
Un processus crée un segment de mémoire partagée ou demande à utiliser un segment déjà créé. (shmget)
Un processus (le même ou un autre) demande au système d’initialiser un pointeur sur cet espace (shmat)
•Ce pointeur contiendra en fait une adresse de mémoire virtuelle différente pour chaque processus - •qui sera traduite au moment de l’exécution en adresse physique identique pour tous les processus utilisant cette mémoire partagée. L'adresse physique est inaccessible au programmeur.
L’accès à des variables définies dans un segment de mémoire partagée nécessite en général une synchronisation rigoureuse entre les processus: cette synchronisation sera réalisée le plus souvent par des sémaphores
Aux segments de mémoire partagée sont associés des droits d'accès de type Unix
Mémoire partagéeMémoire partagée
02/11/06Programmation multitâche sous Unix Isaip-Esaip 29
Mémoires partagées: primitivesMémoires partagées: primitives
Création :
int shmget(key_t key, int size, int flg) : retour = shm_id
Attachement :int shmat(int shmid, const void *shmadr, int flg);
adr = 0 choix de l’adresse par le système d’exploitation
Une même région peut être attachée plusieurs fois à des adresses différentes
Retour : adresse d’attachement effective ou -1
Détachement :
int shmdt(const void *shmadr) : retour = 0 ou -1
Libération de l’espace mémoire uniquement lors du dernier détachement
Opérations de contrôle : int shmctl(int shm_id,int cmde,struct shmid_ds *structure)
cmde = IPC_RMID, IPC_STAT, IPC_SET, SHM_(UN)LOCK (verrouillage en mémoire = pas de swap autorisé)
02/11/06Programmation multitâche sous Unix Isaip-Esaip 30
Mémoires partagées : exempleMémoires partagées : exemple
#include <sys/types.h>#include <sys/ipc.h>#include <sys/shm.h>#include <sys/wait.h>#include <stdio.h>#include <string.h>void main(){ int pid,shmid ; char *mem ; int flag = 0 ; key_t clef ; printf("donnez la clé:");scanf("%ld",&clef);shmid = shmget(clef,100,IPC_CREAT|IPC_EXCL|SHM_R|SHM_W);printf("Identificateur du segment est %d \n",shmid);
pid =fork() ;
if(pid == 0){/*processus fils*/
mem = shmat(shmid,0,flag);
strcpy(mem,"Message pour le pere");
shmdt(mem);
}
else {/*processus père*/
mem = shmat(shmid,0,flag) ;
printf("message reçu de fils :%s\n",mem);
shmdt(mem);
}
wait(0) ;
shmctl(shmid,IPC_RMID,NULL)
}
02/11/06Programmation multitâche sous Unix Isaip-Esaip 31
D'une manière générale, un sémaphore sert à la synchronisation entre les processusUn sémaphore utilisé pour l’exclusion mutuelle (garantir qu’un seul processus accède à un moment donné à une variable partagée), utilisera 2 primitives
Attendre l’accès exclusif à la ressource partagée : si la ressource est déjà utilisée par un processus, le processus qui fait cette demande sera endormi et mis dans une file d’attente de processusLibérer l’accès exclusif à la ressource partagée : si la file d’attente des processus attendant cette ressource est non vide, le processus qui a dormi le plus longtemps est réveillé
La section de programme qui se trouve entre les 2 primitives attendre la ressource et libérer la ressource s’appelle une section critiqueLes sémaphores n’empêchent pas les processus d’accéder à une ressource: un processus « qui ne respecterait pas la discipline» et accéderait à la ressources sans attendre son tour pourrait le faire sans aucune restrictionAux sémaphores sont associés des droits d’accès de type Unix
Pourquoi utiliser un Pourquoi utiliser un sémaphore ?sémaphore ?
02/11/06Programmation multitâche sous Unix Isaip-Esaip 32
Le "mécanisme" des Le "mécanisme" des sémaphoressémaphores
Sémaphore = objet composé :une variable (la valeur du sémaphore)une file d’attente (les processus bloqués attendant la ressource)
Primitives associées :Initialisation (avec une valeur positive ou nulle)Manipulation :
Prendre (P ou Wait) = demande d’autorisation Vendre (V ou Signal) = fin d’utilisation
Principe : sémaphore associé à une ressourcePrendre = demande d’autorisation (puis-je utiliser la ressource?)
Si valeur > = 0 accord, sinon blocageVendre = restitution d’autorisation (je n'ai plus besoin de la ressource)
Si valeur < 0 déblocage d’un processus
02/11/06Programmation multitâche sous Unix Isaip-Esaip 33
Sémaphores : exempleSémaphores : exemple
Parking de N places contrôlé par un feu
02/11/06Programmation multitâche sous Unix Isaip-Esaip 34
Sémaphores : algorithmes des primitives P Sémaphores : algorithmes des primitives P et Vet V
Initialisation(sémaphore,n)valeur[sémaphore] = n
P(sémaphore)valeur[sémaphore] = valeur[sémaphore] - 1si (valeur[sémaphore] < 0) alors
étatProcessus = Bloquémettre processus en file d’attente
finSiinvoquer l’ordonnanceur
V(sémaphore)valeur[sémaphore] = valeur[sémaphore] + 1si (valeur[sémaphore] == 0) alors
extraire processus de file d’attenteétatProcessus = Prêt
finSiinvoquer l’ordonnanceur
02/11/06Programmation multitâche sous Unix Isaip-Esaip 35
UNIX IPC : tableau de sémaphores (1) UNIX IPC : tableau de sémaphores (1)
Création ou attachement :int semget(key_t clé,int nsems,int semflg) : retour = semid
Opérations sur le compteur de sémaphore :int semop (int semid, struct sembuf *spos, int nsops)
Avec struct sembuf { u_short sem_num;short sem_op;short sem_flg; }
sem_op > 0 : La valeur du sémaphore est augmentée de sem_op. "sem_op ressources sont rendues disponibles". Un ou plusieurs processus bloqués pourront être libérés s'il y a suffisamment de ressources. Analogue à V, le processus appelant n'est jamais bloqué.sem_op = 0 : Teste si le sémaphore a la valeur 0. Si ce n'est pas le cas, le processus est mis en attente de la mise à zéro du sémaphore."exemple : un écrivain attend que tous les lecteurs aient fini de lire"sem_op < 0 : La valeur du sémaphore est diminuée de |sem_op|."le processus demande sem_op ressources". Si le résultat est nul, tous les processus en attente de cet événement sont réveillés. Si le résultat est négatif, le processus est bloqué "en attendant de disposer de suffisamment de ressources".
02/11/06Programmation multitâche sous Unix Isaip-Esaip 36
Sémaphores IPC (2)Sémaphores IPC (2)
Opérations de base : exlusion mutuelleP(s) : semop(sem_num, -1, 0)
V(s) : semop(sem_num, +1, 0)
Opérations de contrôle : int semctl(int semid,int semnum,int cmd,
union semun arg)
IPC_RMID, IPC_STAT, IPC_SET,
Commandes spécifiques aux sémaphore : GETVAL : retourne la valeur d’un sémaphore, GETPID : retourne le PID du processus effectuant dernière opération,
etc.
02/11/06Programmation multitâche sous Unix Isaip-Esaip 37
SocketsSockets
Les "sockets", ("prise" ou "connecteur" en anglais), fournissent une interface de programmation qui permet de définir facilement un canal de communication entre 2 processus locaux ou distants
Chaque extrémité d’un canal de communication, est définie par un numéro de port
Un descripteur de socket est analogue à un descripteur de fichier Mêmes primitives read et write que pour les fichiers
Communication bidirectionnelle (contrairement aux pipes)
N°PORT 2
N°PORT 1
Adresse IP 1 Adresse IP 2
Format réseau
Format machine 1 Format machine 2
processus CLIENT
processus SERVEUR
Socket Socket
02/11/06Programmation multitâche sous Unix Isaip-Esaip 38
Communication en mode connecté (TCP)Communication en mode connecté (TCP)
CLIENT SERVEUR
socket() socket()
connect()
bind()
listen()
accept()
write()/Send()
read()/Recv()
read()/Recv()
write()/Send()
close() close()
Transfert de données
Attente nouvelle
connexion
02/11/06Programmation multitâche sous Unix Isaip-Esaip 39
Communication en mode non connecté (UDP)Communication en mode non connecté (UDP)
CLIENT SERVEUR
socket() socket()
bind()
Sendto() Recvfrom()
Recvfrom() Sendto()
close() close()
Transfert de données
Top Related