Vous êtes sur la page 1sur 3

Travaux Pratique : Systemes Temps-Rel

IMI4
Enonc de TP1

Une ligne de chemin de fer relie quatre villes (les villes A, B, C et D). Cette ligne est utilise
par des trains partant de la ville A pour la ville C ainsi que par des trains partant de la ville D
pour la ville A. On vous demande de grer le partage de cette ligne de chemin de fer sachant
que :

Plusieurs trains peuvent partir simultanment de A.


Plusieurs trains peuvent partir simultanment de D.
A un instant donn, chaque segment de la ligne de chemin de fer (segments AB, BC et
DB) ne peut tre utilis que par un train au plus.

On souhaite mettre en place un moniteur (acquisition et libration des ressources) sur les
segments de chemin de fer. Compltez ce programme ci-dessous afin que les rgles ci-dessus
soient respectes. Dans ce programme chaque train est modlis par un thread.

#include <time.h>
#include <pthread.h>
#include <semaphore.h>
#include <stdlib.h>

/* Les villes */
#define A 0
#define B 1
#define C 2
#define D 3

/* Code des threads */


void* train_de_A_vers_C(void* arg);
void* train_de_D_vers_A(void* arg);

/* Moniteur : gestion du chemin de fer */


void utiliser_le_segment(int ville_depart, int ville_arrivee)
{
****
}

void liberer_le_segment(int ville_depart, int ville_arrivee)


{
****
}

int main(int argc, char* argv[])


{

/* Creer autant de trains que


necessaire */
****
}

void* train_de_A_vers_C(void* arg)


{
utiliser_le_segment(A, B);
printf("Train %d : utilise segment AB \n",pthread_self());
liberer_le_segment(A, B);

utiliser_le_segment(B, C);
printf("Train %d : utilise segment BC \n",pthread_self());
liberer_le_segment(B, C);

pthread_exit(NULL);
}

void* train_de_D_vers_A(void* arg)


{
utiliser_le_segment(D, B);
printf("Train %d : utilise segment DB \n",pthread_self());
liberer_le_segment(D, B);

utiliser_le_segment(A, B);
printf("Train %d : utilise segment BA \n",pthread_self());
liberer_le_segment(A, B);

pthread_exit(NULL);
}

int tirage_aleatoire(double max)


{
int j=(int) (max*rand()/(RAND_MAX+1.0));
if(j<1)
j=1;
return j;
}

void attendre(double max)


{
struct timespec delai;

delai.tv_sec=tirage_aleatoire(max);
delai.tv_nsec=0;
nanosleep(&delai,NULL);
}