Inter Process Communication

Les Threads Les processus classiques d'UNIX possèdent des ressources séparées (espace mémoire, table des fichiers ouverts...).

Définition " lightweight processus " (flux léger d'instructions séquentielles, ou processus légers) Partage un espace adresse et quelques autres ressources avec d'autres threads. Le temps de commutation du contexte est inférieur à celui des processus qu'on appels "heavyweight processus " (fork).

Avantages et inconvénients Il existe plusieurs avantages dans l'utilisation des threads: Le « coût » de création d'un thread est bien moindre que celui d'un nouveau processus. Il est possible de partager des variables communes entre les threads.

Avantages et inconvénients Il existe plusieurs inconvénients dans l'utilisation des threads: Si un thread se « plante », c'est toute l'application qui « plante ». Il est impératif de synchroniser les threads pour éviter une corruption des données communes.

Utilisation des threads #include <pthread.h> int pthread_create(pthread_t *thread, pthread_attr_t *attr, void * (*start_routine)(void *), void * arg); void pthread_exit(void *retval); int pthread_join(pthread_t th, void **thread_return);

Utilisation des threads #include <stdio.h> #include <unistd.h> #include <stdlib.h> #include <string.h> #include <pthread.h> char message[255]; // Zone commune void *ma_fonction_thread(void *arg) { printf("dans le threadl'argument etait :%s\n", (char *)arg); sleep(3); strcpy(message, "Bye!"); pthread_exit((void *)"merci pour le temps CPU"); } Variable globale

Utilisation des threads int main() { int res; pthread_t un_thread; void *thread_result; strcpy(message,"Debian inside"); res = pthread_create(&un_thread, NULL, ma_fonction_thread, (void *)message); if (res != 0) { perror("Thread creation failed"); exit(EXIT_FAILURE); } printf("attente de la fin du thread...\n"); res = pthread_join(un_thread, &thread_result); perror("Thread join a foir... echoué"); printf("OK, valeur de retour du Thread join :%s\n", (char *)thread_result); printf("Le message est maintenant %s\n", message); exit(EXIT_SUCCESS); Association du thread avec la fonction. (la fonction est appelée comme étant un thread) Attente de la fin du thread (pthread_exit)

Utilisation des threads Modifiez l'exemple afin d'afficher le pid du thread dans le thread et dans le process principal. ATTENTION Thread est un processus « léger » Pas de PID mais un TID utilisez syscall(SYS_gettid) pour avoir le TID en ajoutant #include <sys/syscall.h>

Supprimer un thread #include <pthread.h> int pthread_cancel(pthread_t thread); int pthread_setcancelstate(int etat, int *etat_precedent);

Synchronisation L'un des avantages des threads est la possibilité d'avoir des variables en commun. Attention aux accès simultanés!

Sémaphores Edsger Wybe Dijkstra était un mathématicien et informaticien néerlandais. C'est lui qui proposa le sémaphore comme un outil de synchronisation en 1963.

Sémaphores Un sémaphore est une variable particulière n'acceptant que des valeurs positives entières et sur lesquelles seules deux opérations sont autorisées : Passeren (Attente) Vrijgeven (Libération) P(monSemaphore) -> bloquer le sémaphore V(monSemaphore) -> libérer le sémaphore

Sémaphores Lors de l'écriture de programmes utilisant des threads dans un système multitâche, il est fréquent de découvrir l'existence de sections critiques de code pour lesquels il est indispensable qu'un processus unique dispose d'un accès exclusif à une ressource particulière.

Sémaphores Une section critique est obligatoirement encadrée par les opérations P (avant la section) et V (après le section) P(monSemaphore) Section critique (Code accédant à des ressources partagées) V(monSemaphore)

Synchronisation avec des sémaphores #include <semaphore.h> int sem_init(sem_t *sem, int pshared, unsigned int value); int sem_destroy(sem_t * sem); int sem_wait(sem_t * sem); int sem_post(sem_t * sem); int sem_trywait(sem_t * sem); int sem_getvalue(sem_t * sem, int * sval);

Synchronisation avec des mutex Mutex (Mutual exclusion) est un sémaphore binaire

Synchronisation avec des mutex P2 P1 Ressource 1

Synchronisation avec des mutex P2 P1 Ressource 1

Synchronisation avec des mutex P2 P1 Ressource 1

Synchronisation avec des mutex P2 P1 Ressource 1 Ressource 2

Synchronisation avec des mutex En 1997, la mission Mars Pathfinder rencontre un problème alors que le robot est déjà sur Mars. Après un certain temps, des données sont systématiquement perdues. Les ingénieurs découvrent alors un bug lié à la synchronisation de plusieurs tâches. Les éléments incriminés étaient les suivants : une mémoire partagée était protégée par un mutex une gestion de bus sur la mémoire partagée, cette routine avait une grande priorité une écriture en mémoire partagée (récupération de données), cette écriture avait la priorité la plus basse une troisième routine de communication, avec une priorité moyenne qui ne touchait pas à la mémoire partagée Il arrivait parfois que l'écriture (priorité faible) s'approprie le mutex. La gestion du bus (priorité haute) attendait ce mutex. La commutation de tâches laissait alors la routine de communication (priorité moyenne) s'exécuter. Or pendant ce temps, le mutex restait bloqué puisque les ressources étaient allouées à la routine de priorité basse. La gestion de bus ne pouvait donc plus s'exécuter et après un certain temps d'attente (une protection insérée par les ingénieurs via un chien de garde), le système effectuait un redémarrage. Un tel problème est connu sous le nom d'inversion de priorité.

Synchronisation avec des mutex #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); int pthread_mutex_destroy(pthread_mutex_t *mutex); int pthread_mutex_lock(pthread_mutex_t *mutex)); int pthread_mutex_unlock(pthread_mutex_t *mutex); int pthread_mutex_trylock(pthread_mutex_t *mutex);

Sémaphore, mémoire partagée et messages. Accès à des ressources partagées entre processus distincts (sans filiation commune).

Mémoire partagée Le partage de mémoire permet à deux programmes indépendants de partager une même mémoire logique. Mémoire partagée P1 P2 Mémoire spécifique à P2 Mémoire spécifique à P1

Mémoire partagée Principe: Création d'un segment mémoire partagée avec fixation des droits (rwx) pour le créateur, les processus du même groupe, les autres processus. Attribution du segment en lecture et/ou écriture au processus Lecture/écriture | Opérations de contrôle sur le segment Libération du segment par le processus

Fonctions de la mémoire partagée. #include <sys/types.h> #include <sys/shm.h> #include <sys/ipc.h> int shmget(key_t clé, int size, int shmflg); void *shmat ( int shmid, const void * shmaddr, int shmflg); int shmctl(int shmid, int cmd, struct shmid_ds *buf); int shmdt (const void * shmaddr);

Utilitaires de sémaphore sous UNIX/LINUX. Comme avec les threads, s'il y a partage d'une même ressource, il faut mettre en place un mécanisme de synchronisation : Les sémaphores.

Utilitaires de sémaphore sous UNIX/LINUX. #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> int semctl (int semid, int semno, int cmd, ...); int semget (key_t key, int nsems, int semflg); int semop (int semid, struct sembuf *sops, unsigned nsops);

Files de messages Une file de messages reprend le principe de boite au lettre. P1 P2 P3 P4 File de messages

Files de messages Une file de messages reprend le principe de boite au lettre.

Files de messages La structure d'un message doit toujours être de la forme suivante: struct msgbuf { long mtype; /* type de message, doit être positif (>0) */ char mtext[1]; /* contenu du message, minimum 1 char */ };

Files de messages Principe: Création d'une file, Consultation des caractéristiques d'une file : Nombre de messages dans la file, Taille de la file, Pid du dernier processus ayant écrit dans la file, Pid du dernier processus ayant lu (extrait) dans la file, Envoi d'un message dans la file, Lecture (extraction) d'un message, en liaison avec son type. Destruction de la file

Fonctions de messages #include <sys/types.h> #include <sys/ipc.h> #include <sys/msg.h> int msgget ( key_t key, int msgflg ); int msgsnd (int msqid, struct msgbuf * msgp, size_t msgsz, int msgflg); ssize msgrcv (int msqid, struct msgbuf * msgp, size_t msgsz, long msg-typ, int msgflg) ; int msgctl ( int msqid, int cmd, struct msqid_ds *buf);

Commandes d'état IPC ipcs -s vous donnera l'état des sémaphores du système. ipcs -m vous donnera l'état des mémoires partagées du système. ipcs -q vous donnera l'état des files de messages du système. ipcrm supprime un sémaphore, une mémoire partagée ou une file de message selon l'option donnée en paramètre.