Projet du cours d ARCHITECTURE Gestion distribué d un parking 3 GI, INSA de Lyon Janvier 2004 1 Objectifs du projet Ce projet a pour but d apprendre à manipuler une application multitâche où les différentes tâches partagent des données. Pour ceci nous utiliserons des processus et comme outils de synchronisation des sémaphores et la mémoire partagée. Les notions de processus, de sémaphore et de mémoire partagée sont définies dans la première partie ainsi que leur manipulation dans l environnement de travail Linux. Ce projet consiste en la gestion d un parking qui a un nombre limité de place. L objectif est de ne pas faire rentrer plus de voitures qu il n y a de places et de ne pas faire attendre des voitures alors qu il y a des places libres dans le parking. On décompose ce problème en plusieurs étapes : gestion d un parking avec 1 seule entrée et 1 seule sortie, puis on rajoute 1 autre entrée et enfin on suppose que le parking a n entrées et m sorties. Ce projet fera l objet d un compte rendu écrit. 2 Gestion des processus Un processus décrit un chemin d exécution. Pour nombre d applications, un processus principal est le seul requis. Cependant, une application peut créer des processus additionnels pour faciliter le travail ou pour augmenter la vitesse de calcul (si possible). La création de processus additionnels vise à exploiter au maximum le temps de traitement du processeur. Les fichiers suivants sont à inclure : #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <errno.h> #include <string.h> 2.1 Création d un processus Sous Linux, chaque processus est identifié par un identificateur de processus (PID, angl. process identifier) de type pid t. La création d un nouveau processus se fait à l aide de la fonction fork() avec le prototype suivant : pid_t fork(void); 1
Après l exécution de la fonction, deux processus contenant le même code sont exécutés par la machine. La distinction entre le deux se fait via les valeurs renvoyées par la fonction fork() : En cas de succès, le PID du fils est renvoyé au processus parent, et 0 est renvoyé au processus fils. En cas d échec -1 est renvoyé dans le contexte du parent, aucun processus fils n est créé, et errno contient le code d erreur (Voir man fork pour plus de détails). L exemple suivant illustre l utilisation : pid_t childpid; /* Création du processus */ childpid = fork (); if (childpid==-1) { fprintf (stderr, "Cannot fork: %s\n", strerror(errno)); if (childpid==0) { /* Code pour le processus enfant ici */... else { /* Code pour le processus parent ici */... 2.2 Attendre la fin d un processus Dans le cas général, le processus parent doit attendre la fin de ses processus enfants avant de terminer son exécution. Ceci peut être réalisé à l aide de la fonction wait() : pid_t wait(int *status); La fonction wait() suspend l exécution du processus courant jusqu à ce qu un enfant se termine, ou jusqu à ce qu un signal à intercepter arrive. En cas de réussite, le PID du fils qui s est terminé est renvoyé, en cas d échec -1 est renvoyé et errno contient le code d erreur (Voir man 2 wait pour plus de détails). L exemple suivant illustre son utilisation dans le cas ou NUMBER OF CHILDREN processus enfants ont été créés : int status, nodeadchildren=0; pid_t pid; while (nodeadchildren<number_of_children) { 2
pid = wait(&status); if (pid>0) { /* Processus enfant a terminé */ ++nodeadchildren; else { /* Retour de wait() à cause d un signal: ignorer */ 3 Les sémaphores Les objets sémaphores du noyau sont utilisés pour compter les ressources. Ils offrent au processus la possibilité d enquêter sur le nombre de ressources disponibles. Si une ressource, ou plus, est disponible, le compte de ressources disponibles est décrémenté en conséquence. Les sémaphores exécutent cette tâche de vérification et de définition automatiquement. Les fichiers suivants sont à inclure : #include <sys/types.h> #include <sys/ipc.h> #include <sys/sem.h> 3.1 Création d un ou de plusieurs sémaphores Un ensemble de sémaphores est créé à l aide de la fonction semget() : int semget (key_t key, int nsems, int semflg); Cette fonction retourne l identificateur de l ensemble de sémaphores associés à la valeur cle key. Cette valeur peut être choisie par l utilisateur, qui doit s assurer que la valeur est unique. L argument nsems signifie le nombre de sémaphores à créer. L argument semflg spécifie les options et les permissions. #define SEMKEY 24081973 /* à remplacer par une clef personelle */ int semid; semid = semget(semkey, 1, 0700 IPC_CREAT IPC_EXCL); if (semid<0) { fprintf (stderr, "Cannot create semaphore: %s\n", strerror(errno)); 3
3.2 Décrémentation d un sémaphore : P Les opérations sur un ou sur plusieurs sémaphores sont exécutées à l aide de la fonction semop() : int semop (int semid, struct sembuf *sops, unsigned nsops); Cette fonction effectue des opérations sur les membres sélectionnés de l ensemble de sémaphores identifié par semid. Chacun des nsops éléments dans le tableau pointé par sops indique une opération à effectuer sur un sémaphore en utilisant une structure struct sembuf définie comme suit : short sem_num; /* Numero du sémaphore (0=premier) */ short sem_op; /* Opération sur le sémaphore */ short sem_flg; /* Options pour l opération */ Si une seule opération est à exécuter, nsops sera donc 1. Le type d opération est signalé par sem op. Si sem op est inférieur à zéro, l opération correspond à une allocation de ressource, souvent appelée P en référence au mot néerlandais passeren (=passer) utilisé par l inventeur Dijsktra : Si la ressource est disponible (la valeur de la sémaphore est supérieure ou égale de la valeur absolue de sem op), la valeur absolue de sem op est soustraite de la valeur du sémaphore. Puis l appel système continue. Sinon le processus s endort jusqu à ce que la valeur du sémaphore devient supérieure ou égale à la valeur absolue de sem op, alors la valeur absolue de sem op est soustraite de la valeur du sémaphore. Puis l appel système continue. L exemple suivant montre la demande de 5 ressources d un sémaphore : struct sembuf op; op.sem_num=0; op.sem_op = -5; op.sem_flg = 0; if (semop(semid, &op, 1)<0) { fprintf (stderr, "Cannot P() on semphore: %s\n",strerror(errno)); 3.3 Incrémentation d un sémaphore : V Pour libérer un sémaphore, c.à.d. incrémenter son compte de ressources, appeler la fonction semop() avec un code d opération sem op positif. Ce même code indique de combien le sémaphore doit être libéré. La fonction est souvent appelée V en référence au mot néerlandais vrijgeven (=libérer) utilisé par l inventeur Dijsktra. Cette opération peut aussi être utilisée pour initialiser la valeur d un sémaphore. 4
3.4 Destruction d un sémaphore La destruction d un ou de plusieurs sémaphores ayant l identification semid se fait avec la fonction semctl() : /* Remove the semaphores */ if (semctl(semid, 0, IPC_RMID)<0) { fprintf (stderr, "Cannot remove semaphores: %s\n", strerror(errno)); 4 La mémoire partagée Sous Linux, les processus créés avec fork() ne partagent pas la même mémoire. Une variable globale définie dans le programme existe donc en plusieurs copies, une par processus. L échange de données entre les processusstrerror en utilisant la mémoire de type standard est impossible. C est pour cela que nous utiliserons la mémoire partagée (angl. shared memory ). Cette mémoire est alloué du système d exploitation (fonction shmget()) et ensuite attachée au processus (fonction shmat(). shmget() renvoie l identificateur du segment de mémoire partagée associé à la valeur de l argument clé. Cette valeur clé peut être choisie par l utilisateur, qui doit s assurer que la valeur est unique. Un nouveau segment mémoire, de taille SIZE, est créé. La fonction shmat() attache le segment de mémoire partagée identifié par shmid au segment de données du processus appelant. Après un fork() le fils hérite des segments de mémoire partagée. Les fichiers suivants sont à inclure : #include <sys/types.h> #include <sys/ipc.h> #include <sys/shm.h> L exemple suivant montre l allocation d un tableau de type unsigned int de taille SIZE éléments : #define SHMKEY 240819732 #define SIZE 1024 int shmid; unsigned int *sharedmemory; /* Create the shared memory */ shmid = shmget (SHMKEY, SIZE*sizeof(unsigned int), 0700 IPC_CREAT IPC_EXCL); if (shmid<0) { fprintf (stderr, "Cannot create shared memory: %s\n", strerror(errno)); 5
/* Attach the shared memory */ sharedmemory = shmat (shmid, NULL, 0); if ((int)sharedmemory==-1) { fprintf (stderr, "Cannot attach shared memory: %s\n", strerror(errno)); 4.1 Libérer la mémoire La mémoire partagée est libérée à l aide de la fonction semctl() : /* Remove the shared memory */ if (shmctl(shmid, IPC_RMID, NULL)<0) { fprintf (stderr, "Cannot remove shared memory: %s\n", strerror(errno)); 5 Gestion interactive des ressources Les sémaphores et la mémoire partagée persistent dans la mémoire de la machine après la fin du programme, si leur déstruction n est pas prévue par le programmeur. La commande ipcs (à utiliser dans un terminal) fournit des informations sur l usage des ressources (sémaphore, mémoire partagés) pour lesquelles le processus appelant a accès en lecture. Enfin, ipcrm détruira la ressource spécifiée par son id, comme illustré par l exemple suivant : ipcs Afficher l état de la machine ipcrm sem 1321 Supprimer le sémaphore ayant l id 1321 ipcrm shm 1487 Supprimer la mémoire partagée ayant l id 1487 6 Gestion d un parking Comme nous l avons précisé au début de cet énoncé, on cherche à modéliser la gestion d un parking comportant un nombre de places limitées. 6.1 Exercice 1 - la gestion des places libres D abord nous nous limitons au cas où les entrés et les sorties ne sont pas gérées par le programme. Donc, la seule contrainte a respecter sera la disponibilité d une place dans le parking. Tous les sémaphores créés par le programme sont à supprimer avant la fin de son exécution. 6
La modélisation Une voiture sera représentée par un processus, qui, à sa création demande à rentrer dans le parking, y reste un temps aléatoire puis en sort et meurt. Le nombre de places dans le parking devient alors une ressource qu il faut manipuler avec des outils de synchronisation. Les constantes NO PLACES : NO CARS : Les fonctions à écrire Le nombre maximal de places dans le parking Le nombre de voitures qui circulent void carlife(int carid) ; Fonction de départ des processus : arrivée de la voiture dans le parking, puis entreée dans le parking, sortie du parking void enterparking(int carid) ; Une voiture entre dans le parking void leaveparking(int carid) ; Une voiture sort du parking int main (void) ; fonction principale du programme qui crée NO CARS processus Fonctions mises à disposition unsigned sleep (unsigned sec) ; long int random (void) ; void srandom (unsigned seed) ; Met en sommeil un processus pendant sec secondes renvoie un nombre aléatoire entre 0 et RAND MAX. A initialiser avec srandom(). utilise son argument comme graine pour engendrer une nouvelle séquence de nombres pseudoaléatoires qui seront fournis lors des appels à random(). 6.2 Exercice 2 - la gestion des entrées et des sorties On s intéresse ici au cas où le parking a 2 entrées et 2 sorties. Chaque entrée et chaque sortie peut être utilisée par une seule voiture à la fois. L utilisation d une entrée ou d une sortie dure 1 seconde, s il y a une place disponible dans le parking. S il n y a pas de place libre dans le parking, la voiture attendra dans l entrée en le bloquant. Les entrées et les sorties sont donc des ressources additionnelles qu il faut manipuler avec des outils de synchronisation. Les constantes NO ENTRIES : Le nombre d entrées (=2) NO EXITS : Le nombre de sorties (=2) 7
6.3 Exercice 3 - La gestion d un tableau de voitures Dans cet exercice nous rajoutons un moyen d accéder aux numéros des voitures dans le parking. Un tableau contenant ces numéros est créé. Après l entrée ou la sortie d une voiture, le tableau est mis à jour. Par conséquent, le tableau doit être accessible par tous les processus. Le contenu du parking est à afficher après chaque entrée et chaque sortie d une voiture. 8