Processus, threads et IPC

Transcription

1 PhL - 29/10/ Page 1 / 5 Processus, threads et IPC Processus et signaux La commande ps Cette commande Unix permet d'afficher différents types d'informations sur les threads et les processus. De nombreuses options sont possibles sur la ligne de commande. Par exemple ps -ef affiche les colones suivantes : UID : User Id, nom du prpriétaire du processus PID : Process Id ; n du processus PPID : Parent PID, n du process parent C : % d'utilisation du CPU STIME : Start time TTY : numéro du terminal qui a lancé le process. TIME : cumulative system time temps total accumulé d'utilisation du CPU. CMD : le nom de la commande qui a lancé le process (argv[0]) ps -elf rajoute des informations sur les threads (light weight process) LWP : n du thread NLWP : nombre de threads / process. La commande time Permet d'afficher les temps d'exécution d'un processus. Par exemple time./a.out affichera : reall : le temps total, y compris les temps d'attente. C'est le temps «ressenti» par l'utilisateur. user : le temps d'utilisation accumulé des ressources CPU (x par autant de processeurs) system : le temps passé à exécuter des appels systèmes. Le temps «user» est quasi indépendant de la charge du système (sauf temps de commutation de contexte) alors que le temps «reall» dépend de la charge. fork() 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. exit() Un processus se termine lorsqu il n a plus d instructions ou lorsqu il exécute la fonction : void exit(int statut) wait() 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 fonction, 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. Si le fils se termine sans que son père l attende, le fils passe à l état defunct. Si, au contraire, le père se termine avant le fils, ce dernier est rattaché au processus initial «init». Le processus initial passe la plupart de son temps à attendre les processus orphelins. kill() 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.

2 PhL - 29/10/ Page 2 / 5 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. Le signal de terminaison normal est 3, et celui de terminaison sans condition est 9. Cette même commande existe aussi en shell. signal (signal, ptr_fonction) Exécute la fonction pointée par ptr_fonction à la réception du signal. alarm ( tps ) Envoie le signal SIGALRM au bout de tps secondes. Programmation 1. Écrire un programme qui va créer un deuxième processus. Le père va afficher les majuscules à l'écran et le fils les minuscules. A la fin du programme, les 2 processus affichent la valeur du pid retourné par f ork(), puis attendent indéfiniment. Vérifiez avec la commande «ps» le lien de parenté entre les 2 processus. 2. Écrire un programme qui attend une chaîne de caractère entrée par l'utilisateur et l'affiche. Si l'utilisateur met plus de 5s à entrer sa chaîne, le programme affiche «Trop tard» et se termine. (utiliser alarm()). 3. Écrire un interpréteur de commande simple qui demande à l'utilisateur d'entrer un nom de programme et 1 paramètre, puis lance le programme (utilisation de execl()). L'interpréteur redemande une commande après exécution. La commande «logout 0» doit terminer votre interpréteur. 4. Même programme, mais accepter un nombre quelconque d'arguments en utilisant ftok( ) et fgets( ). 5. Écrire un programme qui génère un dépassement de pile par appel récursif. La fonction récursive affichera à l'écran l'adresse d'une variable locale à la fonction. En déduire la taille de la pile. 6. Les fonctions getrlimit/setrlimit permet de récupérer/fixer les limitations de ressources d'un processus. Par exemple le code suivant affiche la taille de la pile : struct rlimit rl; getrlimit(rlimit_stack, &rl); printf ("Taille de la pile : %d\n", (int)rl.rlim_cur ) ; Le code suivant fixe la taille de la pile à 1000 : rl.rlim_cur=1000 ; setrlimit(rlimit_stack, &rl); Vérifiez la taille que vous avez trouvé à l'exercice Écrire un programme qui affecte une valeur sur un pointeur NULL (int *p=null ; *p = 7;). Placez un handler afin d'attraper l événement généré. Essayez de corriger le problème. Vous constatez que votre programme entre dans une boucle interminable. Ceci est dû au fait que l'instruction fautive est de nouveau exécutée. Voici en assembleur l'instruction fautive : movl $7, (%rax) Il faut donc soit que %rax soit différent de NULL et pointe au bon endroit, soit sauter cette instruction et exécuter la suivante. Vous pourriez avoir l'idée de corriger ce problème dans la fonction handler (avec un malloc par exemple). Ceci ne changera rien car avant d'appeler la fonction handler Linux sauvegarde le contexte (tous les registres CPU), puis le restitue en sortant de la fonction handler. Il faut donc modifier le contexte qui sera restitué. cf. pour comprendre ce qui se passe et voir sur la plate-forme la résolution du problème.

3 PhL - 29/10/ Page 3 / 5 Les threads en C 1. Écrire un programme qui ouvre un ficher en écriture puis qui crée 2 threads, les attend et ferme le ficher. Le premier thread écrira les nombres de 0 à dans le ficher et l'autre de à Consultez le fichier ainsi créé et analysez le travail de l'ordonnanceur. Attention à compiler avec l'option -lpthread 2. Écrire un programme qui initialise une variable globale à 0 et crée 2 threads. Chacun des threads va incrémenter la variable 5 fois. Afficher la valeur de la variable à la fin de l'exécution du thread main(). 3. Recommencer l'exercice 2, mais cette fois chaque thread va incrémenter la variable 1e6 fois. Ici, il y a un problème d'accès à cette variable globale. Expliquez. 4. Refaire les exercices 1 et 4, mais laissez seulement un coeur du CPU en fonctionnement : Pour cela faire : more /proc/cpuinfo pour connaître le nombre de coeurs de votre PC sudo sh -c "echo 0 > /sys/devices/system/cpu/cpu1/online" pour désctiver le coeur n 1. more /proc/cpuinfo pour vérifier. 5. Écrire un programme permettant de mesurer le quota de temps alloué à un thread Linux entre 2 commutations de contexte. Utiliser la commande shell time pour connaître le temps réel d'exécution. Les sémaphores. Lorsque 2 processus veulent se partager une ressource unique, on met en place un système de sémaphore afin d'arbitrer l'accès à cette ressource. Un sémaphore est une variable, gérée par le système d'exploitation dont le test et l'affectation se font de manière atomique, c est à dire que le système ne peut pas être interrompu au milieu du traitement de ces 2 opérations. De plus, plusieurs processus peuvent avoir accès à cette variable. En général la prise (décrémente de 1) d'un sémaphore par un processus bloquera un autre processus qui voudrait prendre par la suite ce sémaphore ; ce dernier processus sera débloqué quand le premier rendra (incrémente de 1) le sémaphore. Voyons comment gérer les sémaphores sur un système UNIX. Dans un terminal on peut utiliser les commandes suivantes : Pour consulter les sémaphores du système : ipcs t Pour effacer un sémaphore : ipcrm s semid Voici les fonctions qui permettent la gestion des sémaphores en C. Elles viennent de la librairie IPC : Inter Process Communication. Vous pouvez avoir de plus amples renseignements en utilisant la commande man. D abord, quelques fichiers de déclaration : #include <unistd.h> #include <sys/ipc.h> #include <sys/sem.h> Il faut générer une clé unique permettant de repérer de façon univoque la ressource du système (ici un fichier) : key_t cle; int er ; cle=ftok("fichier.txt",0); if (cle==(key_t) -1) { perror ("erreur ftok\n");exit (1); } Créons un ensemble contenant 1 sémaphore avec les droits rw_rw_rw_ : int semid ; semid=semget(cle,1,ipc_creat 0666); if (semid==-1) { perror("erreur semget\n");exit(1); } Initialisons à 1 de notre sémaphore (qui est le sémaphore n 0 de l ensemble ) : union semun { int val; struct semid_ds *buf; ushort *array; } arg; arg.val = 1 ; er=semctl(semid,0,setval,arg); if (er==-1) {perror("erreur semctl\n");exit(1);} Voilà une fonction permettant de rendre le sémaphore no de l'ensemble semid : void rendre (int semid, int no) { struct sembuf op[1];

4 } Physique appliquée et Electronique PhL - 29/10/ Page 4 / 5 int er ; op[0].sem_num=no; // semaphore no op[0].sem_op=1; // libération (à mettre à 1 pour une prise) op[0].sem_flg=0; // operation bloquante er=semop (semid,op,1); if (er==-1) {perror("erreur semop rendre\n");exit(1);} Travail à effectuer : Exclusion mutuelle à l'accès d'une ressource partagée Créez une fonction void prendre (int semid, int no) qui prend le sémaphore no de l'ensemble semid, similaire à la fonction rendre. Reprendre le programme de comptage des 2 threads du chapitre précédent et arbitrer l'incrémentation de cpt. Synchronisation de processus : Créez un programme qui va créer un processus fils. Le père et le fils vont écrire simultanément, l un, les 26 minuscules et l autre, les 26 majuscules, à l écran. Ceci devra donner le résultat suivant : AaBbCcDd Le père attendra la terminaison du fils puis détruira les sémaphores par la fonction semctl( ) Pensez à vider le buffer stdout associé à votre processus par l'appel à fflush(stdlib) Les Verrous Nous venons d'utiliser le mécanisme des sémaphores pour synchroniser les threads. Ce mécanisme prévu à l'origine pour synchroniser les process est lourd à mettre en oeuvre et peu performant. Nous nous proposons ici de reprendre le TP d'écriture minuscule / majuscule mais en arbitrant l'accès par le mécanisme des «verrous d'exclusion mutuelle (mutex)». Voici brièvement les prototypes des fonctions permettant cette gestion : #include <pthread.h> D'abord déclarer un variable mutex qui n'a pas besoin d'être initialisée au préalable.: pthread_mutex_t mutex ; Les verrous d'exclusion mutuelle (mutex) sont créés par pthread_mutex_init. Il en est de différents types (rapides, récursifs, etc.), selon les attributs pointés par le paramètre mutexattr. La valeur par défaut (mutexattr=null) fera l affaire pour notre problème. L'identificateur du verrou est placé dans la variable pointée par mutex. int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *mutexattr); pthread_mutex_destroy détruit le verrou. pthread_mutex_lock tente de bloquer un verrou et met le thread en attente si le verrou est déjà bloqué. pthread_mutex_unlock débloque le verrou et permet donc à un thread mis en attente de continuer son exécution. int pthread_mutex_destroy(pthread_mutex_t *mutex); int pthread_mutex_lock(pthread_mutex_t *mutex); int pthread_mutex_unlock(pthread_mutex_t *mutex); Écrivez en C un programme qui crée 2 threads. Ces derniers écrivent à l écran alternativement les 26 minuscules de l alphabet et les 26 majuscules de l alphabet. Un des threads n écrit que les minuscules et l autre que les majuscules. Le résultat à l écran doit avoir cette forme : AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

5 La mémoire partagée Reprendre l'exercice précédent mais ce coup ci, les 2 processus écriront dans un segment de mémoire partagé. Un index à la case 0 permettra de savoir dans quelle case écrire. A la fin, le père affichera le contenu du segment de mémoire partagée. Voici quelques explications pour mettre en œuvre la mémoire partagé. Les processus ne peuvent pas partager des données simplement car ils s'exécutent dans des segments mémoires séparés. Une façon de contourner ce problème est d'utiliser les fonctionnalités du système d'exploitation. Celui-ci met à disposition un ensemble de fonctions permettant de créer une zone mémoire (mémoire partagée) accessible à tous les processus. Cette zone est repérée par un identifiant (shmid). Voici la liste des fonctions utiles pour la gestion de cette mémoire partagée : shmget int shmget(key_t key, int size, int shmflg); shmget crée un nouveau segment de mémoire partagée ou accède à un segment existant. L'entier retourné est le shmid du segment ou -1 en cas d'erreur. shmflag spécifie les priorités d'accès au segment. Exemple: shmid=shmget(cle,5*sizeof(char),ipc_creat 0666); crée un nouveau segment pouvant contenir 5 caractères, accessible en lecture/écriture par tout processus. cle est utilisé pour identifier le segment mémoire de manière unique. Il est initialisé par la fonction ftok comme dans le cas des sémaphores. int ftok(char* ressource, int flag); shmat void *shmat(int shmid, void *shmaddr, int shmflg); shmat attache le segment de mémoire partagée, associé à shmid, au segment de données du processus appelant. L'adresse à laquelle le segment est attaché est retournée par shmat. Par défaut, le segment est attaché en lecture/écriture. Exemple : char *tab ; tab = shmat (shmid, NULL, 0) ; Par la suite on utilise tab comme un tableau : tab[1]='a'; shmctl int shmctl(int shmid, int cmd, struct shmid_ds *buf); Permet de réaliser des opérations de contrôle sur un segment de mémoire partagée. Le type d'opération est spécifié par l'argument cmd. Par exemple, shmctl(shmid,ipc_rmid,0) détruit le segment associé à shmid. PhL - 29/10/ Page 5 / 5 Les Tubes 1. Écrire 2 programmes que nous nommerons ProgA et ProgB. ProgA lit une chaîne de caractères au clavier et la transmet à ProgB qui la transforme en majuscule. ProgB la renvoie à ProgA. ProgA affiche ensuite le résultat. La transmission se fait à l'aide de tubes nommés. Les deux processus s arrêtent lorsque l utilisateur saisit la chaîne «quit» au clavier. 2. Il existe sur les systèmes UNIX une calculatrice en mode ligne : bc. Par d faut, le programme bc lit une chaîne de caractères représentant une opération à effectuer sur l'entrée standard (stdin) et affiche sur la sortie standard le résultat (stdout). Exemple : /home/toto> bc quit /home/toto> Écrire un programme permettant de saisir une opération au clavier et transmettant celle-ci à un processus correspondant au programme bc qui renverra le résultat au premier processus. La communication entre les deux processus sera réalisée avec des tubes, et votre programme se charge du lancement du processus bc. Le processus père communiquera avec bc via l entrée et la sortie standard de ce processus. Ces dernières auront été redirigées vers des tubes avant que le processus fils ne soit recouvert via l appel système execl() (exécution de la fonction dup2).